学习Java的第一周

前言

初入Java和CSDN，本篇文章仅记录自己学习Java的内容。作为小白知识浅薄等原因可能有错误的内容，待后续学习再更正。

类与类的关系

一.横向关系
1.依赖关系 :在一个方法执行时需要另一个对象作为方法参数出现，如人有喝水的方法需要杯子。
2.关联关系:1-1 1-n n-n 一个类作为成员属性出现在另一个类中。如一个老师对应多个学生，一个学生对应多个老师。是一种强依赖关系。
3.组合关系:包含关系，可以分离，生命周期不一致。如汽车和轮胎。
4.聚合关系:强包含关系，不可分离，生命周期一致。如人和大脑
二.纵向关系
1.继承关系:类与类，父类与子类
2.实现关系:类与接口，类实现接口

继承

继承使用extends修饰，Java中是单继承(一个类只能继承一个类，可以同时被其他类继承)，可以多层继承(一个类可以是他类的父类同时是他类的子类)。子类继承父类时可以调用父类非私有的属性和方法，但是“构造方法不能被继承” 原因：构造方法名称必须和类名一致，构造方法的作用是用于创建这个类的对象。
继承的好处：
1 提高了代码的复用性，提高了软件开发效率。
2 让类与类之间产生了关系，提供多态的前提。

重写和重载

	重写override	重载overload
	最少２个类中，注意访问修饰符能被子类访问到且具有继承关系	同一个类中
访问修饰符	子类不得比父类严格	无关
返回值	一致或者是父类返回值的子类	无关
方法名	相同	相同
参数	相同	不同，参数个数不同或者对应位置的参数类型不同，与参数名无关

final

final代表最终的，能够修饰
1.类：被final修饰的类不可以被继承(没有子类)，但可以继承其他类
2.属性：被final修饰的属性代表常量，必须赋值且只能赋值一次，常量名全大写中间用下划线隔开。修饰基本数据类型时值不能改变。修饰引用数据类型时地址不能改变，值可以变。
3.方法：被final修饰的方法不能被子类重写。

static关键字

static静态的。可以修饰
1.类：外部类和局部内部类不能修饰，可以修饰成员内部类
2.属性(成员变量)：局部变量只能使用final修饰，被static修饰的属性叫静态变量(类变量，类属性)，还可以定义静态常量，通常使用public static final定义。被static修饰的成员变量属于类，不属于这个类的某个对象 (多个对象在访问或者修改 static修饰的变量时，其中一个对象 修改了它的值，那么其他对象看到的都是修改后的) 即多个对象共享同一个static修饰的变量。
3.方法：静态方法。
4.游离块:静态块
注意事项
1.被static修饰的变量建议直接使用类名.属性名调用
2.静态内容优先于对象存在，在静态方法中只能直接访问静态的内容,访问非静态属性需要先创建对象再访问。静态方法中不能使用super和this关键字，静态的内容存在(静态区),

游离块

游离块又叫初始化块，可以使用static修饰成为静态块。
语法： {//需要执行的内容} static{}
执行顺序:静态块优先执行且只执行一次，再执行游离块再执行构造器
例子

①优先执行父类的静态块
②执行子类的静态块
③看main方法中new后面的构造函数先找到对应的构造函数，
④ 查看你找到的构造函数第1行代码
情况1： 什么都没有，则找到父类super()无参构造函数
情况2： 发现this(参数值);则在本类中找到与参数对应的构造函数
情况3： 发现super(参数值); 则去父类中找到与参数对应的构造函数
⑤ 重复第4步操作，直到找到父类的构造器
⑥ 在执行父类的构造器之前，先查看父类中是否定义游离块
情况1： 定义了游离块，则按照定义的顺序，将全部游离块都执行1遍，再执行父类的构造器
情况2：没有游离块，则不执行，直接执行这个构造函数
⑦ 回到子类的那个跳转过来的构造函数，同样在执行子类这个构造函数的时候也要 查看子类中是否有游离块，有则按照定义顺序依次执行1遍，没有则直接执行构造函数
⑧ 则对象创建成功了 输出结果：1423562356

堆和栈

java内存分布：
程序为了提高效率，对数据进行了不同的空间分配,主要有5个区域：
1.堆存放的是所有new出来的东西，成员变量，每个变量都有默认，堆内存使用之后不再使用 就会成为垃圾，此时垃圾回收机制(GC)会自动回收这个垃圾. 先进先出
2.栈存放局部变量 先进后出
3.方法区
4.本地方法区，在查看源代码的时候发现使用 native 关键字修饰，代表和系统相关的方法
5.寄存器:供CPU使用

抽象类

抽象类 ,可以将一个类使用abstract关键字修饰,当不知道一个方法具体算法的时候，把方法定义抽象的,抽象方法又必须定义在抽象类中
特点： 不能被实例化(不能抽象对象)
语法：public abstract class Fu{
public abstract void a(); //抽象方法（没有方法体的方法）
//抽象方法必须定义在抽象类
}
public class Zi extends Fu{
@override
public void a(){ }
}
1.抽象类和抽象方法都需要使用abstract 修饰,抽象方法必须定义在抽象类中
2.抽象类不可以实例化，原因：调用抽象方法没有任何意义
3.只有覆盖了抽象类中所有的方法后,子类对象才可以创建, 否则子类应该也定义成一个抽象类。 原因之所以继承抽象类，更多的是在思想，使面对共同特性的操作会更简单。
4.抽象类，也可以没有抽象方法,但是没有抽象方法的抽象类没有存在意义。
5. 抽象类也可以继承抽象类（单继承,只能继承一个直接的抽象类）
6. 抽象类中可以有构造函数，但是无法创建对象
7. 普通类能定义的抽象类都能定义

接口

接口 ,可以将一个类使用interface关键字修饰,接口是比抽象类更加抽象的类，接口只描述所应具备的方法，并没有具体的实现。
特点： 不能被实例化
语法：public interface 接口名{
公有静态常量; // 默认使用public static final 修饰 int a=10;
抽象方法; //可以定义很多抽象方法，并且可以省略掉 abstract，默认使用 public abstract 修饰
// JDK1.8版本以后可以定义
public default void m1(){ }
public static void f1(){}
}
public class 类名 implements 接口名{}//实现类
1.当多个接口中有1个同名的m方法时，则实现类必须手动重写这个方法） 因为实现类无法判断调用哪个接口的m方法
2.实现类，必须实现接口中所有的抽象方法，才能创建对象。
3.类可以多实现接口，并且接口可以多继承接口
4.实现类 implements 接口1，接口2，接口3{}

匿名对象

顾名思义匿名对象就是没有名字的对象，当一个对象的方法只需要使用一次时就可以使用匿名对象。
例如： new Person().method();
因为没有对象的引用，只能调用一次。
还可做为方法的返回值：return new Person（）；

内部类

1.将类写在其他类的内部，可以写在其他类的成员位置和局部位置
2.分为：成员内部类 静态内部类 局部内部类 ( 匿名内部类 )

public class A{//外部内  修饰符:public 默认不写 final abstract
	//成员内部类 
	//修饰符:private public 默认不写 protectedstatic final abstract
	public class B{}
	//静态内部类
	public static C{}
	public void m(){
		class D{}//局部内部类 只能用final和abstract修饰
	}
}

3.访问特点：
内部类可以直接访问外部类中的成员，包括私有
外部类要访问内部类，必须建立内部类的对象

public class Outer { // 外部类 
	private int a = 10; 
	private int num=1; 
	public void f() { 
		//外部类要访问内部类，必须建立内部类的对象 
		Inner inner1=new Inner(); 
		System.out.println(inner1.x);
		class InnerA{//局部内部类
			public void m{}
		}
		//在方法内部才能使用局部内部类
		new InnerA().m();
	}
	public class Inner { // 成员内部类 
		private int x = 100; 
		private int num=2; 
		//内部类可以直接访问外部类中的成员 
		public void m() { 
			System.out.println(a);
			//外部类中定义的变量和内部类中定义变量名字相同时 
			System.out.println(this.num); // 2 
			System.out.println(Outer.this.num); // 1 
		
		}
		public static void m1(){}
	}
}		

4.创建内部类对象
1>创建成员内部类对象
外部类名.内部类名 自定义对象名=new 外部类构造器().new 内部类构造器(); Outer.Inner oi = new Outer().new Inner();
2>创建静态内部类对象
外部类名.内部类名 自定义对象名=new 外部类名.内部类构造器();

class Test{
	public static void main(String []args){
		//创建成员内部类对象
		Outer.Inner oi=new Outer().new Inner();
		//创建静态内部类对象
		Outer.Inner oi=new Outer.Inner();
		//调用普通m方法
		oi.m();
		//调用静态m1方法
		Outer.Inner.m1();
	}
}

5.匿名内部类 ***
1>匿名内部类 属于局部内部类,说明它定义在方法里面.
2> 最常用到的内部类就是匿名内部类。
3> 抽象类和接口都不能创建对象 我们可以通过一个子类或者实现类来创建对象。现在可以通过匿名内部类来创建一个抽象类和接口的对象

public interface A{
	void a();
}
class B{
	public static void main(String []args){
		A a=new A{//{}这对花括号就是匿名内部类,
			@override
			public void a(){}//实现接口中的方法才能创建对象
		};
	}
}

多态

多态就是对象的多种形态，表现在２个方面，引用多态和方法多态。
１>引用多态是指父类的引用指向子类对象或者接口的引用指向了实现类对象。
２>方法多态是子类重写了父类的方法，当父类的引用指向子类对象时，调用的方法是父类的方法或者是子类重写后的方法，不能调用子类独有的方法。
1.多态的格式
1>普通类的多态格式
父类 自定义变量名=new 子类();
2>抽象类的多态格式
抽象类 自定义变量名=new 抽象类的子类();
3>接口的多态格式
接口名 自定义变量名=new 实现类();
2.引用数据类型的转换
向上转型 向下转型
前提： 类之间存在继承关系(直接或者间接存在继承关系)
类之间转型： 向上转型(自动类型转换，小的转大的) 和
向下转型(强制类型转换，大的转小的，但是有风险)
1> 向上转型：
当有子类对象赋值给一个父类引用时，就是向上转型
父类类型 自定义变量名= new 子类类型();
F f1 = new Z();
f1此时只能调用父类的方法和子类重写后的方法，不能使用子类自有的方法
2> 向下转型：
重要的要求： 只有一个已经向上转型的子类对象才能向下转型 （为了防止转型出错，我们一般会使用 instanceof 关键字 判断这个对象是否可以转型成子类对象）
F f1=new Z();
if( f1 instanceof S){
S s=(S)f1;
}
编译的时候看左边,执行的时候看右边