【狂神说Java】学习笔记Day(09/10)
面向对象2 2026/03/27
封装 get&set
demo04
Student
package oop.demo04; //类 private：私有 public class Student { //属性私有 private String name; //名字 private int age; //年龄 //private char sex; //性别 //虽然在private下不能直接调用属性， //但可以提供一些操作这些属性的方法： //可以提供一些public的get、set方法 //get：获得这个数据 public String getName(){ return this.name; } //set：给这个数据设置值 public void setName(String name){ this.name = name; } public void setAge(int age){ if (age>120 || age<0) { System.out.println("年龄不合法"); }else this.age = age; } public int getAge(){ return this.age; } } Application
package oop.demo04; /* 1.提高程序的安全性，保护数据 2.隐藏代码的实现细节 3.统一接口 4.系统可维护增加了 */ public class Application { public static void main(String[] args) { Student s1 = new Student(); s1.setName("zhx"); System.out.println(s1.getName()); s1.setAge(80); //不合法的 System.out.println(s1.getAge()); } } 继承 extends、super
demo05
Person
package oop.demo05; //在Java中，所有的类，都默认直接或间接继承object //Person 人 ：父类 public class Person /*extends object*/ { //public 公开的 //protected //default //private 私有的 public int money = 10_0000_0000; public void say(){ System.out.println("说了一句话"); } public int getMoney(){ return money; } public void setMoney(int money){ this.money = money; } } Student
package oop.demo05; //学生 is 人 ：是派生类，是子类 //子类继承了父类，就会拥有父类的全部方法 public class Student extends Person { } Teacher
package oop.demo05; //老师 is 人 ：是派生类，是子类 public class Teacher extends Person{ } Application
package oop.demo05; public class Application { public static void main(String[] args) { Student student = new Student(); student.say(); //子类继承了父类，就会拥有父类的全部方法 System.out.println(student.money); //如果父类那边的money用private定义，则不可用，会报错 } } super
Student_super
package oop.demo05; public class Student_super extends Person_super{ public Student_super(){ //隐藏代码：调用了父类的无参构造 //super() //调用了父类的构造器，必须要在子类构造器 “this（）” 的第一行 System.out.println("Student无参执行了"); } private String name = "zhx"; public void print(){ System.out.println("Student"); } public void test1(){ print(); this.print(); super.print(); } public void test(String name){ System.out.println(name); //寒心 System.out.println(this.name); //zhx System.out.println(super.name); //zhanghanxin } } Person_super
package oop.demo05; public class Person_super { public Person_super(){ System.out.println("Person无参执行了"); } protected String name = "zhuanghanxin"; //私有的东西无法被继承 //这里改成private就会报错 public void print(){ System.out.println("Person"); } } Application_super
package oop.demo05; public class Application_super { public static void main(String[] args) { Student_super student = new Student_super(); //这里输出Person无参执行了 Student无参执行了两句 //说明子类包含了隐藏代码（调用了父类的无参构造） //student.test("寒心"); student.test1(); } }super注意点
super调用父类的构造方法，必须在构造方法的第一个
super必须只能出现在子类的方法或者构造方法中
super和this不能同时调用构造方法
Vs this:
代表的对象不同：
this：指本身调用者这个对象
super：代表父类对象的应用
前提
this：没有继承也可以使用
super：只能在继承条件下才可以使用
构造方法：
this（）：本类的构造
super（）：父类的构造
重写 Override
A
package oop.demo05; //继承 public class A extends B{ //Override 重写 public void test(){ System.out.println("A=>test()"); } }B
package oop.demo05; //重写是方法的重写，与属性无关 public class B { public void test(){ System.out.println("B=>test()"); } }Application_AB
package oop.demo05; public class Application_AB { public static void main(String[] args) { //静态方法和非静态方法的区别很大！ //当子类父类都是static，即都是静态方法时， //方法的调用只和左边，和定义的数据类型有关 A a = new A(); a.test(); //输出A=>test() //父类的引用指向了子类 B b = new A(); b.test(); //当子类父类都是static时，输出B=>test() //当子类父类都不是static时，输出A=>test() //非静态方法：重写 } }小结
需要有继承关系，子类重写父类的方法
方法名必须相同
参数列表必须相同
修饰符：范围可以扩大但不能缩小： public>protected>default>private
抛出的异常：范围可以被缩小，但不能扩大： ClassNotFoundException --> Exception（大）
子类和父类的方法必须要一致；方法体可不同
为什么需要重写？
父类的功能需要，子类不一定需要，或者不一定满足
多态
demo06
Person
package oop.demo06; public class Person { public void run(){ System.out.println("run"); } }Student
package oop.demo06; public class Student extends Person { @Override public void run(){ System.out.println("son"); } public void eat(){ System.out.println("eat"); } }Application
package oop.demo06; public class Application { public static void main(String[] args) { //一个对象的实际类型是确定的 //new Student() //new Person() //而可以指向的引用类型就不确定了：父类的引用指向子类 //Student 能调用的方法都是自己的或者继承父类的 Student s1 = new Student(); //而Person 是父类型，可以指向子类，但不能调用子类独有的方法 Person s2 = new Student(); Object s3 = new Student(); s1.eat(); //输出eat s2.run(); //输出son，子类重写了父类的方法，执行子类的方法 //对象能执行哪些方法，主要看对象左边的类型，和右边的关系不大 ((Student)s2).eat(); //进行了一个强制转换 高转低 Person-->Student } }小结
注意事项：
多态是方法的多态，属性没有多态
父类和子类：有联系才能转换，无联系如：String和Student就会类型转换异常 ClassCastException
存在条件：继承关系、方法需要重写、父类引用指向子类对象 Father f1 = new Son（）；
不能重写的特例：
static 静态方法，属于类，不属于实例
final 常量 被final定义后不能被继承
private