java/day08

一,super关键字
–1，概述
super表示父类对象的一个引用
在子类中用，用来调用父类的功能
和this一样，如果出现在了构造方法里，必须是第一条语句
二,方法重写
–1，概述
英文名Override,发生在父子类里的关系
子类继承了父类以后，可以使用父类的所有功能，如果想改-方法重写
语法要求：要有足够的权限（子类的权限要>=父类原来的权限）
子类的方法签名/声明 必须和父类 一样
访问权限：public > protected > default > private
三,继承中的用法
–1,成员变量
package cn.tedu.oop;
//测试 继承里的成员变量
public class Test1 {
public static void main(String[] args) {
//TODO 创建对象测试
new Zi().show();
//对属性的操作：要么打印要么赋值
}
}
class Fu{
String name = “jack”;
}
class Zi extends Fu{
String name = “rose”;
int age = 20 ;//成员变量
public void show() {
int age = 10 ;//局部变量
System.out.println(age);//10，就近原则，优先使用局部变量
System.out.println(this.age);//20，this调用了本类的成员变量
System.out.println(name);//使用了子类的资源rose
//1,super代表父类对象的引用。Fu super = new Fu();
//2,super用在子类中，调用父类的功能
System.out.println(super.name);//使用了父类的资源jack
}

	}

--2,方法
	package cn.tedu.oop;
	//测试 继承里的方法
	//总结：
	//1,子类：可以使用继承自父类的所有方法（除了private的）
		//还可以 扩展自己的特有的方法
		//还可以 修改继承来的方法--方法的重写
		//语法要求：有足够的权限（>=） + 子类的方法声明/签名 必须和父类一样
	//2,方法重写，影响了子类的方法体。但是对父类不能产生影响。
	//3,开发时的原则：OCP开闭原则 -- 关闭源码修改 -- 开放功能扩展
	public class Test2 {
		public static void main(String[] args) {
			Zi2 z = new Zi2();
			z.eat();//重写前，使用了父类的。重写后，使用了子类的
	//		z.play();//是父类的私有资源,只能在父类中使用
	//		z.coding();//使用了子类扩展的
		}
	}
	class Fu2{
		public void eat() {
			System.out.println("啥都吃");
		}
		private void play() {
			System.out.println("啥都玩");
		}
	}
	//1,子类继承父类后,可以使用父类的所有方法(除了private的)
	class Zi2 extends Fu2{
		//3,子类除了能用父类的,还可以自己扩展,还可以改--方法重写
		//要求:子类要有足够的权限 + 方法声明和父类一样
		 public void eat() {
	//4，验证：重写后，对原来父类的功能，有影响吗？--没有，遵循OCP原则
	//		 super.eat();
			 System.out.println("吃 猪肉");
		 }
		//2,子类除了能用父类的,还可以自己扩展
		public void coding() {
			System.out.println("敲代码");
		}
	}

--3,构造方法
	package cn.tedu.oop;
	//测试 继承里的构造方法
	//总结：
	//1，构造方法的作用是：用来灵活的new
	//2，继承后，子类构造方法里会隐藏super()--意思是会自动调用父类的无参构造
	//3，如果父类没给无参构造，子类，只能调用父类的含参 构造
	public class Test3 {
		public static void main(String[] args) {
			new Zi3();
		}
	}
	class Fu3{
		//TODO
		public Fu3() {
			System.out.println(1);
		}
		public Fu3(int a) {
			System.out.println(100);
		}
	}
	class Zi3 extends Fu3{
		public Zi3() {
			//1,构造方法里,隐藏了super(),会自动调用父类的 无参的 构造方法！
			//3,super关键字,如果出现在了构造方法里,必须是第一条语句
	//		super();
			super(666);//2,触发的是父类的  含参 构造方法
			System.out.println(2);
		}
	}
--4,继承的练习
	package cn.tedu.oop;
	//练习 继承
	public class Test4 {
		public static void main(String[] args) {
			Demo d = new Demo();
			//重写前cn.tedu.oop.Demo@15db9742,重写后abc
			System.out.println(d.toString());
		}
	}
	class Demo extends Object{
		//重写
		public String toString() {
			return "abc";
		}
	}
	class Fu4{
		//TODO Constructors..
		public Fu4(int a) {//2,如果只提供含参构造,此时,无参构造就没了!
			System.out.println(1);
		}
		//TODO Fields..
		int age = 10;
		//TODO Methods..
		public void eat() {
			System.out.println(1);
		}
	}
	class Zi4 extends Fu4{
		//TODO 5,重写：有权限+方法声明和父类一样
		public void eat() {
			System.out.println(100);
		}
		public Zi4() {
	//		super();//1,是隐藏着的,会自动调用父类的无参构造
			super(100);//3,只能调用父类的含参构造
		}
		public void show() {
			//4,通过super调用了父类的成员变量
			System.out.println(super.age);
		}
		
	}

四,static关键字
–1,测试
package cn.tedu.oop;
//测试 static关键字
public class Test5 {
public static void main(String[] args) {
//TODO 创建对象测试
Person p = new Person();
p.eat();
System.out.println( p.age );
p.sleep();
System.out.println( p.name );
//1,static的资源，可以通过对象访问+类名访问
Person.sleep();
System.out.println( Person.name );
Person p1 = new Person();
p1.name=“快乐星球”;
Person p2 = new Person();
System.out.println(p2.name);
Person p3 = new Person();
System.out.println(p3.name);
Person p4 = new Person();
System.out.println(p4.name);
}
}
class Person{
//TODO 普通资源
int age = 10;
public void eat() {
//TODO 4.2，普通资源可以调用所有资源(普通的/静态的)
System.out.println(1);
System.out.println(name);
}
//TODO 静态资源
//1,static 可以修饰 成员变量和方法
//2,static资源优先于对象的加载
//3,static资源是共享的，可以直接被类名调用
static String name = “tony”;
static public void sleep() {
//TODO 4，静态资源调用普通资源?–不能直接调用，必须修饰成static的
// System.out.println(age);
//TODO 4.1，静态资源调用静态资源?–可以
System.out.println(name);
System.out.println(1);
}
}
五,静态代码块
–1,概述
也拥有static关键字的所有特点
静态代码块 在 成员位置 static{…}
静态代码块 用于 项目的初始化
–2,测试
package cn.tedu.oop;
//测试 static代码块
public class Test6 {
public static void main(String[] args) {
new Student();//
new Student();//
new Student();//
new Student();//
new Student();//
//执行顺序:
//当类加载时,执行静态代码块
//当new/实例化时,执行 构造代码块和构造方法
//当方法被调用时,执行 局部代码块
}
}
class Student{
//TODO 静态代码块:在成员位置+用来初始化项目+类加载时触发
static {
System.out.println(“静态代码块”);
}
//TODO Constructor:在成员位置+用来new
public Student() {
System.out.println(“构造方法”);
}
//TODO 构造代码块:在成员位置+用来提取构造方法里的共性+new时触发
{
System.out.println(“构造代码块”);
}
//TODO 局部代码块:在局部位置+用来控制变量的作用范围+调用方法时
public void show() {
{
System.out.println(“局部代码块”);
}
}
}

六,final关键字
–1,代码
package cn.tedu.oop;
//测试 final关键字–可以修饰类/方法/变量
public class Test7 {
public static void main(String[] args) {
Zi5 z = new Zi5();
z.eat();
// z.name = “rose”;//修改属性的值
System.out.println( z.name );//打印属性的值
}
}
//1，final修饰的类，不能被继承
//The type Zi5 cannot subclass the final class Fu5
//final class Fu5{
class Fu5 {
//2,final修饰的常量，只能继承，值不能被修改
//The final field Fu5.name cannot be assigned
final String name= “jack”;
//3,final修饰的方法，只能继承，不能重写
final public void eat() {
System.out.println(1);
}
}
class Zi5 extends Fu5{
// //重写:
// public void eat() {
// System.out.println(100);
// }
}

扩展:–面试题
–1，类和对象的关系
–2，封装的好处：提高了程序的安全性
–3，this和super的区别
this代表的是本类对象的一个引用,可以调用一个类的资源
super代表的是父类的对象的一个引用,在子类中可以调用父类的资源
如果是在构造方法里，this和super都必须是第一条语句
–4，overload和override的区别
overload是重载，是一个里的 方法名相同，但是参数列表不同 的现象。
override是重写，是继承后的 子类想要修改父类原有功能 的现象。
重载是为了体现出程序的灵活性
重写就是为了改父类的功能
重写要求的是：子类的方法声明/签名 必须和父类一样 + 子类有要有足够的权限