Java3 2021.6.25

使用类调用实例变量和类变量=类名.变量名
四个控制访问级别：
1、private
该成员只能在当前类内部被访问
2、default
没有特定的访问控制符，默认不写权限符号的均为default，该成员或外部类就可以被相同包下的其他类访问
3、protected
这个成员既可以被同一个包内其他类访问，也可以被不同包类访问，用于继承关系时，想被子类用，但不想被其他类用
4、public
谁都可以访问

package practice;
import java.util.*;
public class Main{
	private String name;//只能通过getset函数访问和操作
	private int age;
	public void setName(String name) {
		if(name.length()<=6||name.length()>=2)
		{
			this.name=name;
		}
		else {
			System.out.println("不符合要求");
		}
		}
	public String getName() {
		return this.name;
	}
	public void setAge(int age) {
		if(age<=100||age>=0) {
			this.age=age;
		}
		else {
			System.out.println("不合法");
			return;
		}
	}
	public int getAge() {
		return this.age;
	}
}

关于构造器
1、创建对象初始化使用，自定义构造器用于改变程序本身的默认初始化

package practice;
import java.util.*;
public class Main{
	public String name;
	public int count;
	public Main(String name,int count) {
		this.name=name;
		this.count=count;
	}
	public static void main(String[] args) {
		Main tc=new Main("疯狂",1);
	}
}

2、构造器也可以重载
3、可以利用this调用另一个重载构造器
但是这个只能在构造器中使用，而且必须作为构造器的第一条语句

package practice;
import java.util.*;
public class Main{
	public String name;
	public String color;
	public double weigh;
	
	public Main() {}
		public Main(String name,String color) {
			this.name=name;
			this.color=color;
		}
		public Main(String name,String color,double weight) {
			this(name,color);//调用第二个重载构造器
			this.weight=weight;
		}
}

类的继承
1、每个类只有一个直接父类，但可以有多个父类
2、java.lang.Object是所有类的父亲

package practice;
import java.util.*;
public class Main{
	public double weight;
	public void info() {
		System.out.println(weight);
	}
	public static void main(String[] args) {//主函数是可以写在父类里的
		Apple a=new Apple();
		a.weight=56;//访问父类实例变量
		a.info();
	}
}
class Apple extends Main{
}

重写父类方法：
1、遵循方法名相同
2、形参列表相同
3、子类返回值类型要比父类小或相等
4、子类方法抛出的异常类要比父类方法声明抛出的异常类更小或相等
5、子类方法访问权限要比父类的访问权限更大
ps：覆盖的方法修饰权限也要相同，不能一个是类方法（有static），一个是实例方法（无static）
6、如果父类方法是private修饰的，那子类如果有同名方法，不属于重写，算重新定义方法
7、如果方法名相同而形参不同，则属于子类与父类重载问题
注意主函数只能写在主类里

package practice;
import java.util.*;
public class Main{
	public void fly() {
		System.out.println("我在飞");
	}
	public static void main(String[] args) {
		Tuoniao os=new Tuoniao();
		os.fly();
	}
}
class Tuoniao extends Main{
	public void fly() {
		System.out.println("我又在飞");//由于同名就是重写了该方法
	}
}

Super限定：在子类中调用被覆盖的父类方法
1、不能出现在static修饰的方法中
2、如果在构造器中使用super，super用于限定该构造器初始化的是该对象从父类继承得到的实例变量，而不是该类自己定义的变量
3、若子类变量与父类变量同名，则会发生隐藏父类变量，super可以访问被覆盖的父类变量

package practice;
import java.util.*;
public class Main extends BaseClass{
	public int a=7;
	public void accessOwner(){
		System.out.println(a);
	}
	public void accessBase() {
		System.out.println(super.a);
	}
	public static void main(String[] args) {
		Main sc=new Main();
		sc.accessOwner();//输出7
		sc.accessBase();//输出5
	} 
}
class BaseClass{
	public int a=5;
}

ps：如果子类和父类没有同名的不需要用super或者父类名
如果直接使用a，程序查找顺序：方法局部变量，类里成员变量，父类里成员变量

package practice;
import java.util.*;
class Parent{
	public String tag="疯狂";
}
class Derived extends Parent{
	private String tag="轻量级";
}
public class Main{
	public static void main(String[] args) {
		Derived d=new Derived();
		//System.out.println(d.tag);这句话出错因为private
		System.out.println(((Parent)d).tag);//强制向上转型
	}
}

调用父类构造器

package practice;
import java.util.*;
class Base{
	public double size;
	public String name;
	public Base(double size,String name)
	{
		this.size=size;
		this.name=name;
	}
}
public class Main extends Base{
	public String color;
	public Main(double size,String name,String color) {//子类构造器要借用父类成员变量要调用父类构造器
		super(size,name);//用super调用父类构造器，必须在构造器语句的第一条
		this.color=color;
	}
	public static void main(String[] args) {
		Main s=new Main(5.6,"a","b");
		System.out.println(s.size+s.name+s.color);
	}
}

super调用的是父类的构造器，而this调用的是同类里的重载构造器，二者不可能同时出现
this与super的对比（在调用构造器方面）

package practice;
import java.util.*;
class Creature{
	public Creature() {
		System.out.println("无参数构造器");
	}
}
class Animal extends Creature{
	public Animal(String name) {
		System.out.println("带一个参数的构造器"+name);
	}
	public Animal(String name,int age) {
		this(name);//调用同一个类里构造器
		System.out.println("带两个参数的构造器");
	}
}
public class Main extends Animal{
	public Main() {
		super("啊这",3);//显式调用父类构造器
		System.out.println("Main无参数构造器");
	}
	public static void main(String[] args) {
		new Main();
	}
}