Java 学习笔记

其实并没有什么用，只是用来训练一下md的写法和hexo的一些命令，Java是一个完全面向对象的东西，有过C和C++的基础，学起来会狠轻松，稍微写一下与C不同的东西

public：可以省略，默认为public
创建新文件：File->new->java peoject->sre->右键->new->class
调节字体快捷键: ctrl-+=(_-)
扩展以及快捷键:
syso+(alt+/) ： 扩展成为System.out.println();
main+(alt+/) ：扩展main
ctrl+shift+o ：import java.util.Scanner;（需要再用了函数的情况下导入）
ctrl + 鼠标点击： 查看详情
Ctrl+m :左右框消失
alt+s：Generate Getters and Setters…,get和set函数；Constractor 构造函数
Scanner scanner = new Scanner(System.in);
鼠标选择部分代码 然后ctrl+shift+/ 注释
ctrl+d ： 删除一行
如果是static声明的对象，可以直接用类名加函数名的方法调用函数 class.func()

float的最大值（同理可求最小值，double类似）

1
2
float a;
a = scanner.nextFloat();

注释：和c一样，加了一个文档注释/** 然后回车
标识符：数字 字母 下划线 美元符号$

数据类型：
byte(位) 8位
long 64位
boolean 布尔类型 true||false
小数默认是double类型,所以必须加一个f表示float类型
float f = 1.1f;
//Unicode表示字符
char c1 = ‘\u66f9’; \u+编码 上网查

&&短路与 前面不满足条件 直接返回 效率高
&不断路与 所有判断完才返回
^ 异或 关于表达式

break结束本层循环
break加标签(outer)是跳出被标签标记的循环

1
2
3
4
5
6
7
8
outer:
for(int i=1;i<=10;i++) {
	for(int j=1;j<=i;j++) {
		if(i==4)  break outer;
		System.out.print(i + "*" + j + "=" +(i*j)+"  ");//九九乘法表
	}
	System.out.println();//空行
}

return 直接跳出循环

数组定义的两种方式： //栈区初始化为0 默认值是0
int[] []int
静态初始化：

1
int arr[] = new int[] {1,2,3};

动态初始化：

1
2
int a[] = new int[3]; 二维静态初始化：
int a[][] = new int[][] {{1,1,1},{2,2,2},{3,3,3}};

二维动态初始化：

1
int a[][] = new int[3][3];

遍历数组：

1
2
3
for(int i=0;i<arr.length;i++) 
for(int j:a)     //foreach方法遍历
	System.out.println(j);     //每次将数组中的值赋给j

类和对象：

1
2
3
4
Person yy;//定义对象
yy = new Person();//对象实例化
//或者
Person yy = new Person();

函数
对于函数参数的传递，若传送的是对象，则传递的是引用(地址)，在函数中改变对象的值，对象的值会真的改变

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//不固定参数的写法 类型+...然后起个名字
public class Person {
	public void HOBBIES(String ...hobbies) {    //String类型
		for(String s:hobbies)
			System.out.println(s+" ");
	}
	public void PRINTINT(int ...numbers) {      //int类型
		for(int i:numbers)
			System.out.println(i);
	}
	public static void main(String[] args) {
		Person yy = new Person();
		yy.HOBBIES("aaa","bbb","ccc");
		yy.PRINTINT(1,321,13,56);
	}
}

返回值
返回值和c差不多，不在赘述

方法

方法的重载：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class study {
	public void add(int a,int b) {
		System.out.println("方法1:"+(a+b));
	}
	public void add(int a,int b,int c) {
		System.out.println("方法2:"+(a+b+c));
	}
	public void add(int a,double b) {
		System.out.println("方法3:"+(a+b));
	}
	public static void main(String[] args) {
		study dx = new study();
		dx.add(1,2);
		dx.add(1,2,3);
		dx.add(1,2.456);
	}
}
//如果add有返回值不同，接收的变量类型和add的返回值类型相对应

静态调用方法

1
2
3
4
5
6
7
8
public class study {
	public static void func() {
		System.out.println("静态");
	}
	public static void main(String[] args) {
		study.func();    //写类名，如果new了一个对象，调用会有警告
	}
}

递归调用方法：：不赘述
this的使用，表示此本对象

1
2
3
4
5
6
Person(String name, int age) {
	System.out.println("非默认");
	this.name = name;
	this.age = age;
	System.out.println(this.name +" "+ this.age);
	}

String类：

1
2
String name1 = "yy";///在对象池赋值
String name2 = new String("yyy");///引用 相当于指针

字符串的反转:

1
2
String name = "123456789";
name = new StringBuffer(name).reverse().toString();

字符有很多要学习的对方，得刷题熟悉一下。

继承
一个包中已经定义了一个Person的类，在另一个Class中定义Yy类，可以这么写

1
public class Yy extends Person

搜一下super的用法，这个不是视频能够完全弄好懂的。

final
1.final声明的类不能被继承
2.final声明的方法不能被子类覆盖
3.final声明的变量不能被修改，即为常量

1
public final class Person

抽象类

1
2
3
public abstract class Study{
	public abstract void fun();
}

相当于模板，天生的父类，不能被实例化，在子类中要具体实现父类中的函数。
在抽象类中函数只需要声明，不能够实现。

接口
interface定义接口

1
public interface A{}

implement实现接口

1
2
3
4
5
public class Test implement A
public class Test implement A,B///实现多个接口
Test  t = new Test();///利用接口
t.a();
t.b();

先继承，后实现接口(写下class这一行的)
接口的继承：接口可以多继承

多态

1
2
3
4
//父类引用指向Dog类的具体实现
Animal animal = new Dog();
animal.func();
//调用的是Dog中的func函数

转型

1
2
Dog dog = (Dog)animal;//向下转型
Animal animal = (Animal)dog//像上转型

Object
Object是所有类的父类

instanceop
返回布尔类型

1
2
System.out.println("dog对象是否属于Animal类"+(dog instanceof Animal));
System.out.println("dog对象是否属于Dog类"+(dog instanceof Dog));
1
2
3
4
5
6
7
8
9
public static void func(Animal animal){
	if(animal instanceof Dog){
		(Dog)animal.say();
	}
	if(animal instanceof Cat){
		(Cat)animal.say();
	}
	
}

匿名内部类
只使用一次，这个不太明白

包装类
装箱和拆箱

1
2
3
int a = 1;
Integer i = new Integer(a); //装箱   Integer i = new Integer(1);
int b = i.intValue(); //拆箱

自动装箱和拆箱

1
2
Integer i = 1; //自动装箱的过程，自动把数据转化为对象
int i2 = i; //自动拆箱，自动把对象传为基本数据

作用

1
2
3
4
5
6
String a = "1";
String b = "2";
int m = Integer.parseInt(a); 
// static int parseInt(String s) static方法可以用类名直接调用 
int n = Integer.parseInt(b);
System.out.println(m+n);

设计模式
饿汉式，懒汉式-单例化

1
2
3
4
5
6
7
8
9
///饿汉式单例实现 先new出一个对象
public class Person {
	private Person() {} // 构造方法私有
	private static final Person p = new Person();//饿汉式单例实现
	public static Person getInstance() { //静态工厂方式
		return p;
	}
	
}
1
2
3
4
5
6
7
8
//懒汉式单例实现 在第一次调用的时候实例化
private static Person p;
public static Person getInstance() { //线程同步 可以加synchronized
	if(p==NULL) {
		p = new Person();
	}
	return p;
}

常用类

日期类:Date​

1
Date date = new Date();

日历类:Calendar

1
2
3
4
5
6
7
Calendar calendar = Calendar.getInstance();//实例化：静态方法，返回一个Calendar实例
calendar.get(Calendar.YEAR);
calendar.get(Calendar.MONTH);
calendar.get(Calendar.DAY_OF_MONTH);
calendar.get(Calendar.HOUR_OF_DAY);
calendar.get(Calendar.MINUTE);
calendar.get(Calendar.SECOND);        ///年月日时分秒 都是int

SimpleDateFormate：

1
2
3
SimpleDateFormat sdf = new SimpleDateFormat(); ///实例化对象
Date date = new Date();                        ///日期对象
System.out.println(sdf.format(date));          ///转化

将输出格式进行封装：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Person {
	public static String PrintFormateDate(Date date,String formate) {
		String s="";
		SimpleDateFormat sdf = new SimpleDateFormat(); 
		if(date!=null) {
			s = sdf.format(date);
		}
		return s;
	}
	public static void main(String[] args) {
		Date date = new Date();
		System.out.println(  PrintFormateDate(date,"yyyy-MM-dd HH:mm:ss")  );
	}
}

String和StringBuffer:
String：对String类型的操作对象，等同于重新生成一个对象，然后将引用指向它；
StringBuffer：操作的始终是一个对象；

1
2
StringBuffer s = new StringBuffer("123");
s.append("456");      ///始终指向一个对象

数学：math(很多都是static类型，类名加函数直接调用)

1
2
3
Math.max(1,2);//比较最大值
Math.round(12.6);//四舍五入
Math.pow(3,4);//求次方，3^4，3的4次方

数组：Arrays

1
2
3
4
5
int arr[] = {5,1,8,44,3,5,8,4,3};
Arrays.toString(arr));   ///toString
Arrays.sort(arr);        ///升序排序
System.out.println( Arrays.binarySearch(arr,44) );//在排好序的arr中，查找位置，从0记
Arrays.fill(arr,0);      ///将arr的值置0

泛型

泛型引入：

我们知道Object是所有类的父类，所以可以运用这个。(这不是泛型)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//ClassOne.java
public class ClassOne {
	private Object object;
	public ClassOne(Object object) {
		super();
		this.object = object;
	}
	public void Print() {
		System.out.println(object.getClass().getName());
	}
    //...省略set函数和get函数
}
//Main.java
ClassOne c1 = new ClassOne(1); //向上转型  这是比较方便好的
c1.Print();
int i = (Integer)c1.getObject();//向下转型  这是比较麻烦的
ClassOne c2 = new ClassOne("111"); 
c2.Print();

泛型：(感觉和c++的差不多一个意思)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
///ClassType 文件
public class ClassType<T> {
	private T a;
	public ClassType(T a) {
		super();
		this.a = a;
	}
	public void Print() {
		System.out.println(a.getClass().getName());
	}
	//...省略set函数和get函数
}
///Main文件
public class Person {
	public static void main(String[] args) {
		ClassType<Integer> c1 = new ClassType<Integer>(1);
		c1.Print();
		ClassType<String> c2 = new ClassType<String>("111");
		c2.Print();	
	}
}

泛型限制

1
2
public class ClassType<T extends Animals> {} ///泛型限制
public class Dog extends Animals{}  //普通限制

通配符泛型

1
2
public static void take(ClassType<?> a){}   //函数
ClassType<Dog> dog = new ClassType<Dog>(new Dog());  //主函数

集合

父类：Collection
List是Collection接口的子接口，也是最常用的接口。此接口对Collection接口进行了大量的扩展，List集合里的元素是允许重复的。

1
2
3
4
5
6
7
//链表 LinkedList
LinkedList<Integer> list = new LinkedList<Integer>();
    list.add(1); list.add(2);list.add(3);
    for(int i=0;i<list.size();i++) {
    	Integer I = list.get(i);
   		System.out.println(I);
    }
1
2
3
4
5
6
7
//ArrayList 
ArrayList<String> al = new ArrayList<String>();
al.add("123");
al.add("456");
for(int i=0;i<al.size();i++) {   //循环输出
    System.out.println(al.get(i));
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//HashMap
public static void main(String[] args) {
		HashMap<String,Person> hm = new HashMap<String,Person>();
		hm.put("Person 1", new Person("张三",10));
		hm.put("Person 2", new Person("李四",20));
		//通过key获取values
		Person P = hm.get("Person 1");
		System.out.println(P.getName());//输出的是   张三
    	//遍历
		Iterator<String> it = hm.keySet().iterator();//获取key的集合，然后获取迭代器
		while(it.hasNext()) {
			String key = it.next();
			Person values = hm.get(key);
			System.out.println(values.getName());
		}
	}

集合的遍历

Iterator遍历集合

1
2
3
4
5
6
7
8
9
10
11
public static void main(String[] args) {
    LinkedList<Person> L = new LinkedList<Person>();
    L.add(new Person("张三",10));
    L.add(new Person("李四",20));

    Iterator<Person> it = L.iterator();
    while(it.hasNext()) {
        Person P = it.next();
        System.out.println(P.getName()+P.getAge());
    }
}

foreach集合

1
2
for(Person P:L)
    System.out.println(P.getName()+P.getAge());
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家