面向对象封装、继承、多态

面向对象：

     把复杂问题通过面向对象的思维方式拆分成每一个单独负责某个分支问题的对象


     类：
        利用类中的成员变量来记录事物的信息叫属性
        利用方法来实现或者描述事事物的行为护着功能叫方法

     成员变量：
        1.可以在类中任意成员中使用，如果有同名的局部变量会被覆盖。
        2.可以赋值也可以不赋值，不赋值则在new的时候采用属性数据类型的默认值    
        嵌套类

     方法：
        方法声明：
        权限控制符   修饰符  返回值类型   方法名（形参列表[,..]）{

        }

        返回值如果是void则不需要return，否则必须return ,return 必须是最后一句话
        形参本质上就是一个一定会得到实参值传递的方法的局部变量

        重载：
        同一类中 方法名相同，形参列表不同（类型和个数）

     构造器：
        作用
            用来配合创建new类的对象的
            代码主要用来实现对象的属性初始化
        语法规定
            1.所有类都必须提供构造器
            2.如果类中没有主动声明构造器，则系统自动默认提供一个无参无内容的构造器
            3.构造器必须跟所在类的名字一样，构造器是一个代码块不能有返回值类型所以不是函数

    this: . 代表当前对象
          ()代表当前类的构造器
    super:.代表当前对象的父对象
          ()代表当前类的父类的构造器

          super()和this()不能同时存在一个构造器中而且如果存在则必须是第一行。

封装：

            包：
                类文件的管理单位
                打包：package
                      import

            访问权限控制符：
                public：同一项目下随便用
                protected：
                被修饰的类成员正常情况下只能本包用，但是如果是其他包中的子类以子类的身份继承用可以
                default  ：一个类的成员被default修饰代表只能被相同包中的其他类或者本类使用
                private
                ：只能本类中
            要求以后所有的类：所有属性私有，同时提供对应的get和set方法

package mianxiangduixianggaoji;

public class text2 {
    //封装
    private String name;
    private int age;
    public text2() {
        super();
    }
    public text2(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        //例如一些其他的方法可以在这加判断
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }   
}

继承：

            Object：是所有类的直接或者间接父类，Object也是个类不参与正常讨论
            what：复用其他类成员的语法，利用 子类  extends 父类
                  java只允许单继承
            why：
                减少代码量
                支持代码复用
                为多态做准备
            how:
                只要满足什么是什么这种关系，就是父子关系就可以使用继承

            继承发生之后对于对象的影响：
                子类对象要想诞生的前提必须先创建父类对象
                子类构造器默认第一行有一个super()
image.png
package mianxiangduixianggaoji;
//继承
public class test1 {
    public static void main(String[] args) {
        Teacher t = new Teacher();
        t.age = 5;
    }
}

class People{
    String name;
    int age;
    People(){
        super();
        System.out.println("People");
        
    }
    
    void sayHello() {
        
    }
}

class Teacher extends People{//默认拥有父类所有属性和方法
    int classNum;
    Teacher(){
        super();
        System.out.println("2111");
        
    }
    void sayHello() {
        
    }
}

package mianxiangduixianggaoji;

public class Tuhao {
    int money;
    public static void main(String[] args) {
        Tuhao tuhao = new Tuhao();
        tuhao.money = 2000000000;
//      Draw d = new Draw("老画家",10);
//      SmallDraw sd = new SmallDraw("老画家", 10);
//      DrawOther dother = new DrawOther("其他画家",10);
        Draw d = new SmallDraw("老画家", 10);
        tuhao.buyDraw(d);
        tuhao.printshanshuimeiren();
    }
    
    public void printshanshuimeiren() {
        Draw d = new Draw("老画家",10);
        d.doDraw(200000000);
    }
    public void  buyDraw(Draw d) {
        d.doDraw(2000000000);
    }
}

class DrawOther{
    private String name;
    private int money;
    public DrawOther(String name, int money) {
        super();
        this.name = name;
        this.money = money;
    }   
    public void doDraw(int money) {
        if(money>1000000) {
            System.out.println("山水大美人儿");
        }else {
            System.out.println("滚");
        }
        
    }   
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getMoney() {
        return money;
    }
    public void setMoney(int money) {
        this.money = money;
    }   
}
class SmallDraw extends Draw{
    public SmallDraw(String name, int money) {
        // TODO Auto-generated constructor stub
        super(name, money);
        System.out.println("跟老画家一模一样");
    }
    
    String name = "xixi";
    public void doDraw(int money) {
        System.out.println("机智一p宝儿姐，阿威十八式大威天龙");
    }   
}

class Draw{
    private String name;
    private int money;
    public Draw(String name, int money) {
        super();
        this.name = name;
        this.money = money;
    }   
    public void doDraw(int money) {
        if(money>1000000) {
            System.out.println("山水大美人儿");
        }else {
            System.out.println("滚");
        }       
    }   
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getMoney() {
        return money;
    }
    public void setMoney(int money) {
        this.money = money;
    }   
}

多态：

一个事物多种形态
对修改关闭对继承开放利用子类来实现修改程序的方式，用来保证程序可维护性

              前置条件：
                必须发生继承：只有继承子类才能成为父类保证同一事物
                必须重写：才能让父类的行为和子类的同一行为表面是一个声明其实实现不一，叫多种形态
                父类引用指向子类对象:
                    引用类型的数据转换：只有存在父子关系，才可能进行转换
                        向上转型：父类引用指向子类对象
                                父类引用调用属性（只能调用父类有的属性，得到的也是父类对象的值）
                                父类引用调用方法，优先执行子类的方法，子类方法中优先使用子类自己的属性

                        向下转型：原本的父类引用指向的对象就是子类对象
                                 前提是必须使用instanceof   判断左边的引用或者引用的对象是否属于右边的类型或者子类的类型

package mianxiangduixianggaoji;

public class test3 {
    //多态：一个事物多种形态
    //  对修改关闭，对继承开放，利用子类来实现修改程序的方式，用来保证程序的可维护性
    
    //前置条件，必须发生继承，只有继承子类才能成为父类保证同一事物
    //必须重写：才能让父类的行为和子类的同一行为表面是一个声明其实实现不一样，叫多种形态
    //父类引用指向子类
    
    int money;
    public static void main(String[] args) {
        test3 tuhao = new test3();
        tuhao.money=200000000;
        
        Draw d = new Draw("老画家",10);
        d.doDraw(200000000);
        
        SmallDraw s =new SmallDraw("小画家",5);
    }
    public void buyDraw(Draw d) {
        
    }
}
class SmallDraw extends Draw{
    public SmallDraw(String name,int money) {
        super(name,money);
        System.out.println("跟老画家一模一样");
    }
    //方法的重新
    public void doDraw(int money) {
        System.out.println("大威天龙");         
    }
}
class Draw{
    private String name;
    private int money;
    public Draw(String name, int money) {
        super();
        this.name = name;
        this.money = money;
    }
    
    public void doDraw(int money) {
        if(money>1000000) {
            System.out.println("大美人儿");
        }else {
            System.out.println("滚");
        }
        
    }
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getMoney() {
        return money;
    }
    public void setMoney(int money) {
        this.money = money;
    }
    
    
}



    //多态向上转型
    
    //向下转型
    
    
    public static void main(String[] args) {
        Father f= new Child();//父类引用指向子类对象
//      System.out.println(f.a);//向上转型的时候输出的是父类的属性，输出子类的属性会报错；
//      f.haha();
//      Child c =(Child)f;//向下转型
//      System.out.println(c.a);
//      System.out.println(c.b);
//      c.haha();
        new test4().getFather(f);
        
    }
    
    public void getFather(Father f) {
        f.haha();
        if(f instanceof Child) {
            Child fd= (Child)f; 
            System.out.println(fd.b);
        }   
    }
}

class Father{
    int a =1 ;
    public void haha() {
        System.out.println("father");
    }
}

class Child extends Father{
    int a =2;
    int b =3;
    public void haha() {
        System.out.println("child");
    }
}

面向对象语法的一些修饰符

            static:静态
                类：静态内部类
                变量：静态变量又叫类变量，可以直接通过类名来调用，类变量整个类所有对象和类本身公用一个
                方法：类方法可以用类名来调用，但是方法中不能使用非静态属性
                块：
                    静态块伴随类的加载而执行，只执行一次

            final:不能被修改
                类：不能有子类
                变量：常量
                方法：不能被重写

            abstract:抽象
                方法：抽象方法  ，没有方法体
                类：抽象类 ，如果一个类中有抽象方法则类必须抽象，但是如果是抽象类可以没有方法
                不能被实例化，有构造器



        子类对象创建过程：
            1.类加载 永远只加载一次，一旦加载完就不用再加载
                1.1 先加载父类
                    1.1.1 先创建父类的静态属性
                    1.1.2 执行父类的静态块代码
                1.2 再加载子类
                    1.2.1 先创建子类的静态属性
                    1.2.2 在执行子类的静态代码块

            2.对象创建
                子类和父类属性先空间先诞生
                2.1 先创建父类对象
                    2.1.1 先创建给父类属性赋值
                    2.1.2 执行父类的普通块
                    2.1.3 执行父类的构造器
                2.2 再创建子类对象
                    2.2.1 给子类属性赋值
                    2.2.2 执行子类的普通块
                    2.2.3 执行子类的普通块

package mianxiangduixianggaoji;

public class test6 {
    //静态块
    public static void main(String[] args) {
        Fathera f1 = new Fathera();
        Fathera f2 = new Fathera();
        System.out.println(f1.a);
        System.out.println(f1.b);
        System.out.println(f1.c);
        System.out.println(f2.a);
        System.out.println(f2.b);
        System.out.println(f2.c);
        Childa c1 = new Childa();
        Childa c2 = new Childa();
        System.out.println(c1.a);
        System.out.println(c1.b);
        System.out.println(c1.c);
        System.out.println(c2.a);
        System.out.println(c2.b);
        System.out.println(c2.c);
        
    }

}

class Fathera{
    int a ;
    int b = getB();
    int c = getC(); 
    Fathera(){
        a = 1;    
        System.out.println("father");  
    }
    static int getB() {
        System.out.println("father的getb");
        return d;
    }
    static int d = 3;
     int getC() {
        System.out.println("father的getc");
        return a; 
    }
    {
        System.out.println("father 的普通块");
    }
    static {
        System.out.println("father的静态块");
    }
}

class Childa extends Fathera{
    int a = 2;
    Childa(){
        System.out.println("child");        
    }
    static int getB() {
        System.out.println("child的getb");
        return d;
    }
     int getC() {
        System.out.println("child的getc");
        return a; 
    }
    {
        System.out.println("child 的普通块");
    }
    static {
        System.out.println("child的静态块");
    }
}
image.png

package mianxiangduixianggaoji;

public class final1 {
//  final:不能被修改
//  类：不能有子类
//  方法:不能被重写
//  变量:常量
}
final class x extends y {
    
} 

class y{
    final void haha() {
        System.out.println("Aaaa");
    }
}
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 216,470评论 6赞 501
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 92,393评论 3赞 392
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 162,577评论 0赞 353
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 58,176评论 1赞 292
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 67,189评论 6赞 388
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 51,155评论 1赞 299
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 40,041评论 3赞 418
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 38,903评论 0赞 274
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 45,319评论 1赞 310
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 37,539评论 2赞 332
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 39,703评论 1赞 348
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 35,417评论 5赞 343
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 41,013评论 3赞 325
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 31,664评论 0赞 22
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,818评论 1赞 269
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 47,711评论 2赞 368
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 44,601评论 2赞 353