JAVA--面向对象(2)封装继承多态和instanceof
面向对象三大特征：封装，继承，多态
一.封装
1.该露的露，该藏得藏
-
我们的程序设计要追求--【高内聚，低耦合】--
-
高内聚：就是类的内部数据操作细节要自己完成不允许外部干涉
-
低耦合：仅暴露少量的方法给外部使用
-
-
封装（数据的隐藏）
-
通常，应该禁止直接访问一个对象中数据的实际表示，而应该通过操作接口来访问，这称为信息隐藏
-
-
记住这句话：属性私有，get/set
package com.oop.demo04;
public class Application {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("王");
System.out.println(s1.getName());
s1.setAge(99);//不合法
System.out.println(s1.getAge());
}
}
/*
1.提高程序的全球性，保护数据
2.隐藏代码的实现细节
3.统一接口，例如get，set，可以往set方法里加一些安全性判断
4.系统可维护增加了
*/
package com.oop.demo04;
//类 封装 private：私有
public class Student {
//学生属性：名字，学号，性别，封装主要是对属性
//属性私有，加了private关键字
private String name;
private int id;
private char set;
private int age;
// 学生的方法：学习()，睡觉()
//alt+insert自动生成get，set方法
//提供一些可以操作这个属性的方法！
// 提供一些public 的get，set方法
//get获得这个数据，
public String getName(){
return this.name;
}
//set给这个数据设置值
public void setName(String name){
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public char getSet() {
return set;
}
public void setSet(char set) {
this.set = set;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if(age>120||age<0) {
this.age = 3;
}else {
this.age = age;
}
}
}
二.继承
1.继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
2.extends的意思值"扩展"，子类是父类的扩展
3.java中类只有单继承，没有多继承
4.继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖，组合，聚合等
5.继承关系的两个类，一个为子类(派生类)，一个为父类(基类)。子类继承父类，使用关键字extends来表示
6.子类和父类之间，从意义上讲应该具有"is a"的关系
7.object类
super:
super注意点：
1.super调用父类的构造方法，必须在构造方法的第一个
2.super必须只能出现在子类的方法或构造方法中
3.super和this不能同时调用构造方法
和this对比：
1.代表对象不同：
this：本身调用者这个对象
super：代表父类对象的应用
2.构造方法
this();本类的构造
super();父类的构造
package com.oop.demo05;
//学生 is 人
//子类继承了父类，就会有父类的所有方法
public class Student extends Person {
public Student() {
//隐藏代码：默认调用了父类的无参构造,下面一行
//super();
super();//调用父类的构造器必须要在子类构造器的第一行
//this("hello");调用子类或父类构造器必须保证在代码第一行
//并且只能二选一
System.out.println("Studen无参执行了");
}
private String name = "ping";
// public Student(String name) {
// }
public void test(String name){
System.out.println(name);//wang
System.out.println(this.name);//ping
System.out.println(super.name);//an
}
public void test1(){
print();
this.print();
super.print();
}
public void print(){
System.out.println("Student");
}
}
package com.oop.demo05;
//在java中所有的类，都默认直接或间接继承oject类
public class Person {
public Person(String name) {
System.out.println("Person有参执行了");
}
public Person() {
System.out.println("Person无参执行了");
}
protected String name = "an";
public void say(){
System.out.println("说了一句话");
}
public void print(){
System.out.println("Person");
}
//私有的东西无法被继承
private int money = 10000000;
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
}
方法重写
重写：需要有继承关系，子类重写父类的方法
1.方法名必须相同
2.参数列表必须相同
3.修饰符，范围可以扩大，但是不能缩小
public>protected>default>private
4.抛出异常：范围可以缩小，但是不能扩大
ClassNotFounException(小)-->Exception(大)
重写：子类的方法和父类必须一致，方法体不同
为什么需要重写:
1.父类的功能，子类不一定需要，或不一定满足
快捷：Alt + insert;override
package com.oop.demo05;
//重写都是方法的重写，与属性无关
public class C {
//静态方法和非静态方法区别很大
//静态方法和左边有关，，非静态：重写
public static void main(String[] args) {
//方法的调用只和左边定义的数据类型有关
A a = new A();
a.test();
//父类的引用指向了子类
B b = new A();//A类重写了父类的方法，和非静态有关
b.test();
}
}
1.动态编译：类型：可扩展性
2.即同一方法可以根据发送对象的不同而采用多种不同的行为方式
3.一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
4.在多态环境下：要调用属性--->看父类，要调用方法--->看子类
-
多态存在的条件
-
有继承关系
-
子类重写父类方法
-
父类引用指向子类对象
-
注意：
多态注意事项：
1.多态是方法的多态，属性没有多态性
2.父类和子类，有联系 类转换异常表示：ClassCastException
3.存在条件：继承关系，方法需要重写，父类引用指向子类对象
father f1 = new Son();
不能重写的方法：
1.static 方法，属于类，它不属于实例
2.final常量
3.private 方法
package com.oop.demo06;
public class Ctest {
public static void main(String[] args) {
//一个对象的实际类型是确定的
//new Student new Person
//可以指向的引用类型就不确定了//父类的引用指向子类
//Student能调用的方法都是自己的或继承父类的
Student s1 = new Student();
//Person夫类型，可以指向子类，但不能调用父类的方法
Person s2 = new Student();//父类的引用指向子类
Object s3 = new Object();
//对象能执行哪些方法，主要看对象左边类型和右边关系
((Student)s2).eat();//子类重写了父类的方法，执行子类的方法
s1.run();
}
}
四.instanceof（类型转换）指引用类型之间的转换
-
instanceof（类型转换）指引用类型之间的转换，判断一个对象是什么类型
-
instanceof判断两个类之间是否有父子关系，有父子关系就ok，没有就不行了
package com.oop.demo06;
public class A {
public static void main(String[] args) {
//类之间的转化：父 子
//C高 B低
C b = new B();
//将b这个对象转换为B类型，我们就可以使用B类型的方法
B b1 = (B) b;
b1.go();
// ((B)b).go();
//子类转换为父类，可能会丢失自己本来的一些方法
C c = b1;
}
}
/*
1.父类的引用指向子类的对象
2.把子类转换为父类，向上转型
3.把父类转换为子类，向下转换，强制转化
4.方便方法的调用，减少重复的代码，简洁
*/
/*
// Object>C>B
// Object>C>D
// Object>String
// System.out.println(X instanceof y);能不能编译通过！！
Object b = new B();
System.out.println(b instanceof B);//true
System.out.println(b instanceof C);//true
System.out.println(b instanceof Object);//true
System.out.println(b instanceof D);//false
System.out.println(b instanceof String);//false
System.out.println("===============");
C c = new B();
System.out.println(c instanceof B);//true
System.out.println(c instanceof C);//true
System.out.println(c instanceof Object);//true
System.out.println(c instanceof D);//false
//声明的c与string,毫无关系，不能编译，直接报错
//System.out.println(c instanceof String);编译报错
System.out.println("===============");
B b1 = new B();
System.out.println(b1 instanceof B);//true
System.out.println(b1 instanceof C);//true
System.out.println(b1 instanceof Object);//true
// System.out.println(b1 instanceof D);编译报错
// System.out.println(b1 instanceof String);编译报错
*/
浙公网安备 33010602011771号