DAY 8 面向对象

面向对象

封装、继承、super、方法重写、多态、instanceof和类型转换

一、封装

1.类

封装主函数

package basic;
/*
封装用处：
1.提高程序的安全性，保护数据
2.影藏代码实现的细节
3.统一接口
4.系统可维护增加
*/
public class a24fengzhuang {
public static void main(String[] args) {
a24fengzhuangStudent s1=new a24fengzhuangStudent();
s1.setName("xiao");
System.out.println(s1.getName());
s1.setShengao(165);
System.out.println(s1.getShengao());
s1.setAge(27);
System.out.println(s1.getAge());
s1.setSex('男');
System.out.println(s1.getSex());

}

}

封装的内聚

package basic;
//类 private 私有
public class a24fengzhuangStudent {
//属性私有
private String name;
private int age;
private char sex;
private double shengao;
//提供一些可以操作这个属性的办法，提供一些public的get、set方法
//get 获得这个数据
public String getName(){
return this.name;
}
// set 给这个数据设置值
public void setName(String name){
this.name=name;
}

public double getShengao() {
    return shengao;
}

public void setShengao(double shengao) {
    this.shengao = shengao;
}
//封装判定是否合法，维护程序
public int getAge(){
    return this.age;}

//Alt+ins 前面有定义后，快速设置get set
public char getSex() {
return sex;
}

public void setSex(char sex) {
    this.sex = sex;
}

public void setAge(int age){
    if(age>100&age<0){
        this.age=0;
    }else{
    this.age=age;}

}

}

2.主函数

package basic;
/*
封装用处：
1.提高程序的安全性，保护数据
2.影藏代码实现的细节
3.统一接口
4.系统可维护增加
*/
public class a24fengzhuang {
public static void main(String[] args) {
a24fengzhuangStudent s1=new a24fengzhuangStudent();
s1.setName("xiao");
System.out.println(s1.getName());
s1.setShengao(165);
System.out.println(s1.getShengao());
s1.setAge(27);
System.out.println(s1.getAge());
}
}

二、继承

image

1.主函数

package basic;

public class a25main {
public static void main(String[] args) {
a25son son1=new a25son();
son1.say();
son1.setMoney(120000);
System.out.println(son1.getMoney());
}
}

2.父类

package basic;

public class a25jicheng {//父类
//public
//private
//protected
//default
private int money=10_0000_0000;
public void say(){
System.out.println("说了一句话");
}

public int getMoney() {
    return money;
}

public void setMoney(int money) {
    this.money = money;
}

}

3.子类

package basic;
//son 派生类：子类 继承了父亲，就会拥有父类的全部public方法
//java 中所有类，默认直接或间接继承object
public class a25son extends a25jicheng {
//ctrl+H 打开继承树
}

4.super

a。注意点：

1.super调用父类的构造器方法，必须在构造方法的第一个
2.super必须只能出现在子类得方法或者构造方法中
3.super和this不能同时调用构造方法

b。Vs this

代表的对象不同：
this 本身调用者这个对象
super 代表父类对象的应用
前提：
this：没继承也可以使用
super：只能在继承条件中使用
构造方法：
this（）；本类的构造
super（）；父类的构造

主函数

package basic;

public class a25main {
public static void main(String[] args) {
a25son son1=new a25son();
son1.say();
son1.setMoney(120000);
System.out.println(son1.getMoney());
a25son son=new a25son();
son.test("xiaoxiaoxiao");
System.out.println("============");
a25son a=new a25son();

}

}

父类

package basic;

public class a25jicheng {//父类
//public
//private
public a25jicheng(){
System.out.println("25jicheng被执行了");
}
private int money=10_0000_0000;
protected String name="xiao";
public void say(){
System.out.println("说了一句话");
}

public int getMoney() {
    return money;
}

public void setMoney(int money) {
    this.money = money;
}

}

子类

package basic;
//son 派生类：子类 继承了父亲，就会拥有父类的全部public方法
//java 中所有类，默认直接或间接继承object
public class
a25son extends a25jicheng {
//ctrl+H
public a25son(){
//调用父类的构造器，必须在子类构造器第一行
System.out.println("a25son 无参执行了");
}
private String name="xiaoxiao";
public void test(String name){
System.out.println(name);
System.out.println(this.name);
System.out.println(super.name);
}
}

5.方法重写

main函数

package basic;

public class a26fangfachongxie {
public static void main(String[] args) {
//方法的调用只和左边，定义的数据类型有关
a26a a=new a26aSon();
a.test();
//父类的引用指向了子类
a26aSon b=new a26aSon();
b.test();
//非静态,引用指向子类
a26aSon d=new a26aSon();
d.tt();
a26a c=new a26aSon();
a.tt();
}
}

父类

package basic;

public class a26a {
//静态
public static void test() {
System.out.println("father");
}
public void tt(){
System.out.println("baba");
}
}

子类

package basic;
public class a26aSon extends a26a {
//静态

//@Override重写
//public int hashCode() {
    //return super.hashCode();}
public static void test() {
    System.out.println("son");
}

public void tt(){
    System.out.println("erzi");
}

}

6.方法重写

image

main

package basic;

public class a27main {
public static void main(String[] args) {
//一个对象实际类型是确认的，new Father() new son()
//可指向的引用类型就不确定,父类的引用指向子类
//son 能调用的方法都是自己的或者继承父类的
a27Father a27father=new a27son();//父类指向子类，但不能调用子类独有的方法//a.eat();无法运行
a27son a27son= new a27son();
Object object=new a27son();//默认的通用类
a27son2 a27son2 =new a27son2();
a27father.run();//子类重写了父类的方法，执行子类的方法
a27son.run();
( (a27son)a27father).eat();//子类重写了父类的方法，执行子类的方法

    a27son.eat();
    a27son.say(); //son 能调用的方法都是自己的或者继承父类的
    // Object >String
    // Object >27Father>a27son
    // Object >27Father>a27son2
    System.out.println(object instanceof a27son);//左边对象与右边的类是不是，父子关系
    System.out.println(object instanceof a27Father );//左边对象与右边的类是不是，父子关系，父子关系
    System.out.println(object instanceof a27main);//左边对象与右边的类是不是，父子关系，无父子关系
    System.out.println(object instanceof String);//左边对象与右边的类是不是，父子关系，无父子关系
    //System.out.println(27Father instanceof  String);//编译报错，同级无法比较
   // System.out.println(a27son instanceof a27son2);//编译报错，同级无法比较
   // System.out.println(a27son2 instanceof  String);//编译报错，同级无法比较
    ((a27son)a27father).eat();//高转底（a27father---》a27son,调用son的方法）//父调用子类
    a27son.say();//子调用父类方法
    /*
    1.父类引用指向子类的对象；
    2.把子类转换为父类，可以直接调用函数，向上转换
    3.把父类转换为子类，向下转换需要强制转换，
    4.方便方法的调用，减少重复的代码
    封装、继承、多态 抽象类
     */
}

}
/*

多态注意事项

1.多态是方法的多态，属性没有多态
2.父类和子类，有联系 类型转换异常 ClassCastException
3.存在条件：继承关系，方法需要重写，父类引用指向子类对象 Father a=new son();

一、static 方法，属于类，它不属于实例
二、final 是常量；无法重写
三、private 方法；无法重写

*/

father

package basic;

public class a27Father {
public void run(){
System.out.println("father");
}
public void say(){
System.out.println("say some thing");
}
}

son

package basic;

public class a27son extends a27Father {
public void run(){
System.out.println("son");
}
public void eat(){
System.out.println("eat");
}
}

son2

package basic;

public class a27son2 extends a27Father{
}

posted @ 2022-12-01 22:38  vicxiao  阅读(30)  评论(0)    收藏  举报