面向对象02
1.static 的使用
public class Student { // 学生类 public String name; public int age; public Student() { System.out.println(" 无参......."); } // 静态代码块 执行顺序是 书写的顺序 static { System.out.println("静态代码块1"); } static { System.out.println("静态代码块2"); } // 在实例化对象之前 执行的 普通代码块 执行顺序是 书写的顺序 { System.out.println("普通代码块1"); } { System.out.println("普通代码块2"); } }
public class StudentTest { static int num; public static void main(String[] args) { /** * 观察 静态代码块 普通代码块 和 无参构造方法的执行顺序 */ Student stu = new Student(); // num必须是static修饰的才能调用 System.out.println(num); } public void sayHello() { // 普通方法中调用了 静态变量 System.out.println(num); } }
2.static 实现 投票
public class Student { // 学生类 public String name; public int age; /** * 定义学生可以投票的数量 * static 让所有的对象 共享这一个变量 */ public static int tickets = 100; // 带参构造 public Student(String name, int age) { super(); this.name = name; this.age = age; } /** * 定义一个投票的方法 */ public void getTickects() { System.out.println("感谢您的参与！剩余票数：" + (--tickets)); } }
public class StudentTest { public static void main(String[] args) { Student stu1 = new Student("小黑1", 30); Student stu2 = new Student("小黑2", 40); Student stu3 = new Student("小黑3", 50); System.out.println("第1个姓名：" + stu1.name); System.out.println("第2个姓名：" + stu2.name); System.out.println("第3个姓名：" + stu3.name); System.out.println("开始投票*******************"); // 调用投票的方法 stu1.getTickects(); stu1.getTickects(); stu2.getTickects(); stu3.getTickects(); } }
通过类名可以直接访问 类中的静态属性或者方法！
3.封装
/** * static: * 01.修饰变量 或者方法 属于 类 * 02.在类被加载的时候 就执行了！ 并且只执行一次！ * 03.非静态的方法中可以直接访问 静态方法或者静态属性 * 04.静态的方法中不可以直接访问 非静态方法或者非静态属性 * 05.普通的方法不能定义 静态属性 * * 面向对象的三大特性： * 1.封装 隐藏内部细节！ 安全！ * 01.属性私有化 其他的类访问不了！ * 02.创建供外部访问的接口！ get（取值） 和 set（赋值）方法 * 03.在 set（）中书写 逻辑判断 * * 2.继承 * 3.多态 * * */ public class Student { // 01.属性私有化 private String name; private int age; private String sex; // 性别 /** * 02.创建供外部访问的接口！ get（取值） 和 set（赋值）方法 * * alt +shift + s +r */ public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } // 在 set（）中书写 逻辑判断 public void setAge(int age) { // 如果age<0 或者大于150 if (age < 0 || age > 150) { System.out.println("因为是不健康的输入！我们给您默认值！"); this.age = 50; // 默认值 } else { this.age = age; } } public String getSex() { return sex; } // 做逻辑判断 public void setSex(String sex) { if (sex.equals("男") || sex.equals("女")) { this.sex = sex; } else { this.sex = "男"; } } // 无参构造 public Student() { super(); } // 带参构造 public Student(String name, int age, String sex) { super(); this.name = name; this.age = age; this.sex = sex; } }
public class StudentTest { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); // 通过无参构造创建一个学生对象 Student stu = new Student(); System.out.println("请您输入姓名："); // 把用户的输入直接赋值给 对象的name属性 stu.setName(scanner.next()); System.out.println("请输入您的年龄："); stu.setAge(scanner.nextInt()); System.out.println("请输入您的性别：（男/女）"); stu.setSex(scanner.next()); System.out.println("您的姓名是：" + stu.getName()); System.out.println("您的年龄是：" + stu.getAge()); System.out.println("您的性别是：" + stu.getSex()); } }
4.继承
/** * 所有动物的父类 */ public class Animal { /** * 定义属性 */ private String name; // 姓名 private int health; // 健康值 /** * protected修饰的属性 在子类中可以访问 无论子类和父类 是否在相同的一个包中！ * 并不是 子类的对象 可以访问！ * protected String strain; // 品种 */ public Animal() { System.out.println("Animal的无参构造"); } public Animal(String name, int health) { System.out.println("Animal的带参构造"); this.name = name; this.health = health; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getHealth() { return health; } public void setHealth(int health) { this.health = health; } }
public class Dog extends Animal { private String strain; // 子类特有的属性 品种 public void sayHello() { System.out.println("这是" + this.getName() + " 打招呼的 方法！"); } /** * super()！调用父类的无参构造 * super(String,int)调用父类的带参构造 * 上面两个只能在子类的构造方法中书写，必须位于第一行！ * super. 这相当于 父类的对象！ * this. 相当于本类的对象！ * 可以出现在非静态的方法中！ * super不能访问访问父类 私有的属性或者方法 * * 我们如果实例化子类对象！没有显示的调用父类的代参构造！ * 那么 都会执行父类的无参构造！ * */ public Dog() { System.out.println("Dog 的无参构造方法"); } public Dog(String strain) { super("小黑黑", 200); System.out.println("Dog 的带参构造方法"); this.strain = strain; } public String getStrain() { return strain; } public void setStrain(String strain) { this.strain = strain; } }
/** * java单根继承性 extends 实现代码的复用！ * * 子类和父类 满足 is -a 的关系！ * 小狗是动物！ * 小猫是动物！ * * 子类中能继承父类的什么？ * 01.非私有的属性以及方法！ * 02.父类的构造方法 不允许被继承！ * */ public class AnimalTest { public static void main(String[] args) { Dog dog = new Dog("金毛"); } }
5.重写
public class Animal { // 每个动物都有吃饭 public void eat() { System.out.println("父类animal吃东西的方法......"); } // 验证返回值 public Animal getAnimals() { return new Animal(); } // 验证父类的静态方法 子类不能重写 public static void testStatic() { System.out.println("父类的静态方法"); } }
public class Cat extends Animal { /** * 方法重写 * 01.不同类！ 子类重写父类的方法 * 02.方法名相同，参数列表也要相同！ * 03.访问修饰符不能严于父类！ * 04.如果父类方法的返回值 是一个父类， * 那么子类中重写的方法 可以是父类的子类！ * 05.父类的静态方法不能被重写！但是方法名 可以 一致 * 06.父类私有的方法 也不允许 被重写！ */ public void eat() { System.out.println("小猫咪 吃鱼......."); } // 验证返回值 是 子类也可以 public Cat getAnimals() { return new Cat(); } public static void testStatic() { System.out.println("子类的静态方法"); } }
6.重写equals方法
public class Student { private String name; private String sex; private int age; // 重写equals public boolean equals(Object o) { if (this == o) { //先判断内存地址 return true; } if (!(o instanceof Student)) { //判断类型 return false; } // 向下转型 Student student = (Student) o; if (this.age == student.getAge() && this.name.equals(student.getName()) && this.sex.equals(student.getSex())) { return true; } else { return false; } } public Student(String name, String sex, int age) { super(); this.name = name; this.sex = sex; this.age = age; } public Student() { super(); } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getSex() { return sex; } public void setSex(String sex) { this.sex = sex; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } }
public class TestStudent { public static void main(String[] args) { Student stu1 = new Student("小黑", "男", 50); Student stu2 = new Student("小黑", "男", 50); Student stu3 = stu2; System.out.println(stu1 == stu2); // false System.out.println(stu2 == stu3); // 重写我们equals 只要是 student类中的各个属性相等 我们就让两个对象相等 System.out.println(stu2.equals(stu1)); //true } }
7.多态的使用
public class Animal { private String name; // 姓名 private int health; // 健康值 public Animal() { } public Animal(String name, int health) { this.name = name; this.health = health; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getHealth() { return health; } public void setHealth(int health) { this.health = health; } // 父类的方法 public void gotoHospital() { } }
public class Master {// 主人类 // 给宠物看病的方法 public void gotoHospital(Animal animal) { if (animal instanceof Dog) { animal.gotoHospital(); animal.setHealth(100); } if (animal instanceof Cat) { animal.gotoHospital(); animal.setHealth(100); } } }
public class Dog extends Animal { private String strain; // 子类特有的属性 品种 // 子类重写父类的方法 @Override public void gotoHospital() { System.out.println("小狗狗看病...."); } public Dog() { } public Dog(String strain) { super("aa", 12); this.strain = strain; } public String getStrain() { return strain; } public void setStrain(String strain) { this.strain = strain; } }
public class Cat extends Animal { private String sex; public Cat() { super(); } // 子类重写父类的方法 @Override public void gotoHospital() { System.out.println("小猫咪看病...."); } public Cat(String sex) { super(); this.sex = sex; } public String getSex() { return sex; } public void setSex(String sex) { this.sex = sex; } }
/** * 多态： * 不同的对象，去做同一件事情，产生了不同的结果！ * * 主要分两种： * 01.编译时的多态 （方法重载） * sayHello(Student stu) * sayHello(Teacher stu) * sayHello(Animal stu) * 02.运行时的多态 * java在运行期间，根据调用方法的类型，来决定使用哪个对象的方法！！ * * 多态存在的三个条件： * 01.要有继承关系 * 02.要有方法的重写 * 03.父类的引用指向了 子类的对象 * */ public class AnimalTest { public static void main(String[] args) { // 父类的引用指向了 子类的对象 Animal dog = new Dog("金毛"); dog.setName("小金"); dog.setHealth(42); Animal cat = new Cat("女"); cat.setName("小花"); cat.setHealth(45); Master master = new Master(); master.gotoHospital(dog); System.out.println("小gougou的健康值：" + dog.getHealth()); } }
一道多态的面试题
public class A { public String show(D d) { return " A and D"; } public String show(A a) { return " A and A"; } }
public class B extends A { public String show(B b) { return " B and B"; } public String show(A a) { return " B and A"; } }
public class C extends B { }
public class D extends B { }
public class Test { public static void main(String[] args) { A a1 = new A(); A a2 = new B(); // 父类的引用 指向了 子类的对象 B b = new B(); C c = new C(); D d = new D(); System.out.println(a1.show(b)); System.out.println(a1.show(c)); System.out.println(a1.show(d)); System.out.println(a2.show(b)); System.out.println(a2.show(c)); System.out.println(a2.show(d)); System.out.println(b.show(b)); System.out.println(b.show(c)); System.out.println(b.show(d)); // B类中没有方法 回去 父类中查询 有没有对应的方法 } }
