JAVA基础---面向对象

面向对象思想:
面向过程:一步一步做事情
面向对象:找对象来做事情,对象本身包含做事情的步骤
特点:
角色发生转变,执行者变成指挥者
特征:
封装
继承
多态
类和对象
类:对事物的描述
对象:这一类事物的实体(实例)
面向对象:我们需要操作实实在在的对象
定义类的步骤
1.类名
2.成员变量 – 属性 – 通常的叫法 属性
3.成员方法 – 行为 – 通常的叫法 方法

/*学生类:            成员变量:姓名,年龄,性别,学号            成员方法:学习,吃饭,睡觉,考试            定义类的步骤:                1.给类起名字                2.成员变量,不用赋值                3.成员方法,不要static             使用学生类:                强调:文件名和测试类的名字保持一致.*/class StudentTest{    public static void main(String[] args){        //测试学生类         //创建对象        Student s = new Student();        //使用成员变量//      String name = s.name;//      int age = s.age;//      char ch = s.sex;//      String sn = s.studyNum;        //System.out.println(name +"----"+age +"----"+ ch +"----"+sn);        //赋值         s.name = "小明";        s.age = 27;        s.studyNum = "001";        System.out.println(s.name +"----"+            s.age +"----"+s.studyNum);              //使用成员方法        //回想 sc.nextInt();        s.study();        s.eat();        s.sleep();        s.test();    }}class Student{    //成员变量    //姓名    String name ;    //年龄     int age ;    //性别//  char sex ='男';    //学号    String studyNum ;    //成员方法    //学习    public void study(){        System.out.println("好好学习...");    }    //吃饭    public void eat(){        System.out.println("好好吃饭...");    }    //睡觉    public void sleep(){        System.out.println("好好睡觉...");    }    //考试    public void test(){        System.out.println("努力考出好成绩...");    }   }

使用对象的步骤
1.创建对象
2.对象名.方法名()
1.赋值
2.取值
3.使用其他成员方法

成员变量和局部变量的区别
成员变量和局部变量的区别
1.类中的位置不同
成员变量: 类中方法外
局部变量: 方法声明上和方法定义中
2.内存中的位置也不同
成员变量: 堆内存 – 跟着对象走
局部变量: 栈内存 – 跟着方法走
3.生命周期不同
成员变量: 随着对象的存在而存在,随着对象的消失而消失
局部变量: 随着方法的调用而存在,随着方法的结束而消失
4.初始值不同
成员变量: 有默认值
局部变量: 没有默认值,必须给赋值才能使用.

/*    当方法的参数为类名的时候,其实它想要的是一个对象 */class CookTest{    public static void main(String[] args){        //创建对象        Cook c = new Cook();        Waiter  w = new Waiter();        c.call(w);    }}class Waiter{    public void duanCai(){        System.out.println("狗肉汤来了~~~~");    }}class Cook{    public void call(Waiter w ){        w.duanCai();    }   }

方法的形式参数是类名的时候,实际上要的是一个对象
匿名对象:
调用一次方法的时候
作为参数传递的时候

/*    匿名对象 :就是没有名字的对象 ;    没什么用的用途 :        方法是调用一次的时候(初始化数据的时候,可能会用到,后面的接口可以用到)    */class CarTest{    public static void main(String[] args){        Car c = new Car();        c.brand = "奔驰";        c.color = "黑色";        //c.run();        //匿名对象        new Car().brand = "宝马"; //创建一个对象,品牌赋值为 宝马          new Car().color = "白色"; //又创建一个对象,颜色赋值为 白色     //  new Car().run();          // 又创建一个对象,没有赋值         Car c2 = new Car();        c2.show();        c2.show();        new Car().show();    //  new Car().show();           }}class  Car{    String brand;    String color;    public  void run (){        System.out.println( brand+"===" + color );    }    public void show(){        System.out.println("小心驾驶,分不够扣的");    }}

面向对象的三大特征:
封装:
步骤:1.隐藏类的实现细节 –private
2.提供对外的公共访问方式 – public 成员方法,get()/set(),
private:私有的,修饰成员
作用: 隐藏成员,不让外界访问.
特点: 通过公共的访问方式才行.
this: 当前对象的引用
作用: 修饰成员变量,表示当前对象的属性
static: 静态(饮水机)
特点:所有类的对象,共享数据
类名.成员 使用成员

/*    问题:set方法中形参单词,该成和成员变量单词一致,发现,成员变量不能被赋值了.    怎么解决这个问题?     使用this关键字     把this关键字修饰方法内的变量,可以表示其为成员变量    this表示当前对象 */class  GoddessTest{    public static void main(String[] args){ //      //创建对象 //      Goddess gd = new Goddess();//  //  gd.name  = "奥万大";//  //  gd.age = -20; ////      gd.setName("奥万大");//      gd.setAge(20);//  //      System.out.println(gd.getName()+"---"+gd.getAge());//      //gd.walk();        //创建对象        Goddess gd = new Goddess();        gd.setName("先生");        gd.setAge(104);        gd.say("你的问题在于想的太多,书读的太少");         }}class Goddess {     //成员变量    private String name; //姓名       // name 只可以在Goddess中访问private    private int age;        //成员方法    //给姓名赋值    public void setName(String name){        this.name = name;     }    //获取姓名的值     public String getName(){        return this.name;    }     //给年龄赋值    public void setAge(int age){        this.age  = age;     }    public int getAge(){        return this.age;    }    public void walk(){         System.out.println("我是:"+name + "--我"+ age +"岁,我来走红毯....");    }    public void say(String words){          System.out.println("我是"+name + ",孩子,我今年"+ age +"岁了,"+ words);    }}``` 继承        概述:很多类,有相同属性,方法,我们把相同内容,抽取出来,封装一个新的类,让很多类与新的类发生了extends关系.        特点:1.提高复用性, 维护性             2.单继承,多层继承,通过多层继承,实现了继承体系        注意事项:            1.父类有的子类省略            2.父类中private的,不能访问            3.构造方法,不行             4.不能随便继承        super:表示父类存储的空间的标识.(假装是父类对象引用)        顶层父类是 Object类,它没有父类 .        成员关系:            成员变量(同名):就近原则,使用子类                          构造方法:没有继承                 加载顺序:子类所有的构造方法,默认调用父类super();                            但是你可以,显示的调用父类super(参数);                注意事项:                    private修饰父类属性:不能继承                    super位置:第一行            成员方法(同名):子类,就是重写                重写概述:子类和父类的方法声明完全一致(修饰符,返回值类型,参数列表)                注意事项:                    私有:不能被重写                    权限:子类重写父类方法时，访问权限不能更低            静态方法:看起来想重写的时候,你得使用静态.但是根据多态,我们知道,并没有真正的被重写.<div class="se-preview-section-delimiter"></div>

这里写代码片
“`
重写与重载的区别:
override: 子类和父类的方法声明完全一致(修饰符,返回值类型,参数列表)
overload: 本类中,方法名相同,参数列表不同,跟返回值类型无关.
final: 最终
概述: 修饰 类,变量,方法
特点:被final修饰的东西,不能被修改

“`
/*

继承:    1.抽取相同部分,封装为Person类     2.使用继承来实现 学生和老师  注意:    继承,不能什么都复制. 构造方法就得自己完成,显示调用  

*/
class Demo{
public static void main(String[] args){
Student s = new Student();
s.setName(“文强”);
s.setAge(20);
System.out.println(s.getName() +”—–”+s.getAge());
s.show();
Student s2 = new Student(“程程”,19);
System.out.println(s2.getName() +”—–”+s2.getAge());
Teacher t = new Teacher();
Teacher t2 = new Teacher(“班主任”, 20);
}
}
class Person{
//成员变量
private String name;
private int age;
public Person(){}
public Person(String name,int age){
this.name = name;
this.age = age;
}
public String getName(){
return this.name;
}
public void setName(String name){
this.name = name;
}
public int getAge(){
return this.age;
}
public void setAge(int age){
this.age = age;
}
//
// public void show(){
// System.out.println( name + “–” +age);
// }
}
class Student extends Person{
//构造
Student(){
super();
// System.out.println(“—–”);
}
// Student(String name ,int age){ //你不能直接把继承前的版本的有参构造拿过来,因为 this 不能访问 父类中 private的成员变量
// this.name = name;
// this.age = age;
// }
// 有参构造
Student(String name ,int age){
super(name,age);
}
public void show(){
System.out.println( super.getName() + “–” +super.getAge());
}
}
class Teacher extends Person{
Teacher(){
}
Teacher(String name ,int age){
super(name,age);
}
}

“` 重写与重载的区别:
override: 子类和父类的方法声明完全一致(修饰符,返回值类型,参数列表)
overload: 本类中,方法名相同,参数列表不同,跟返回值类型无关.
final: 最终
概述: 修饰 类,变量,方法
特点:被final修饰的东西,不能被修改

/*final关键字    final修饰局部变量    在方法内部，该变量不可以被改变    在方法声明上，分别演示基本类型和引用类型作为参数的情况*/class FinalTest{    public static void main(String[] args){        final int x = 10;    //  x =20;  // 错误: 无法为最终变量x分配值        System.out.println(x);        final Person p  =  new Person ("程程" ,19);        p.show();        p.setName("文强"); //因为 p 地址值     //  p.setAge(25); //  错误: 无法为最终变量age分配值        // p = new Person("文强"); // 错误: 无法为最终变量p分配值        p.show();        System.out.println("---------------");        Person p2 = new Person();        p2.setAge(99);        p2.show();    }}class Person{    String  name;    final int age; // 不能被重新赋值的     Person(){}    Person(String name,int age){        this.name = name;        this.age = age;    }    public void setName(String name){        this.name = name;    }    public void setAge(int age){        this.age = age;     }    public void show(){        System.out.println("我是"+ name +"--" + age);    }}

多态:
概述:一种事物的多种形态 看看这个电影(我的个神啊!)
前提:
1.继承–子类和父类继承关系
2.重写– 重写父类中 的方法
3.父类引用指向子类对象
Fu f = new Zi();
成员关系:
成员变量:
编译看左边,运行看左边
构造方法
同继承
成员方法:
编译看左边,运行看右边(重写 同名成员方法)
静态方法:
编译看左边,运行卡左边
子类特有的方法:
向上转型:默认的,自动提升,父类引用指向子类对象
向下转型:父类想要使用子类的特有方法
目标数据类型 变量名 = (目标数据类型) 父类引用;

如下:

/*    问题:每添加一种水果,就需要个榨汁机添加一种方法 ,太麻烦了 .    解决:使用多态        1.多态的前提,有继承         2.重写beiZha()        3.榨汁机中的方法,改成一个,而且 不用再添加方法了            注意:这一个方法的参数为父类     好处:体现了多态的扩展性 和维护性       */class ZhaZhiJiTest{    public static void main(String[] args){        ZhaZhiJi z = new ZhaZhiJi();//      Apple a = new Apple();//      Banana b = new Banana();        //      z.zha(a);//      z.zha(b);        Fruit f = new Apple(); //new 苹果 榨苹果汁                f = new Huolongguo();        z.zha(f);    }}class ZhaZhiJi{    public void zha( Fruit f){            f.beiZha();    }//  public void zha( Apple apple){//          apple.beiZha();//  }//  public void zha( Banana banana){//          banana.beiZha();//  }   }class Fruit{    public void beiZha(){        System.out.println("榨水果汁");    }}class Apple extends Fruit {    public void beiZha(){        System.out.println("榨苹果汁");    }}class Banana extends Fruit{    public void beiZha(){        System.out.println("榨香蕉汁");    }}class Huolongguo extends Fruit {    public void beiZha(){        System.out.println("榨火龙果 汁");    }}

抽象类:
概述:把类更细化,提取出来抽象的东西,叫抽象类.(动物,水果,工具)
特点:
1.格式:abstract class 类名{
}
2.方法抽象,类必须抽象,反之不一定.
3.构造方法:有,不能创建对象,只能初始化数据
4.实例化:不能直接实例化,但是实例化子类
5.子类要求:
1.要么是抽象的
2.要么重写所有的抽象方法
成员特点:
成员变量:可以使变量,也可以常量
构造函数:有
成员方法:抽象,非抽象
面试题: abstract 不能和哪些关键字共存?
private 冲突 – 对子类隐藏,而 abstract 必须让子类重写
final 冲突 – 不能被重写,矛盾
static 无意义– 类名调用,没有方法体,无意义
如下 :

/*    抽象 -- 具体      抽象--看不见,摸不着,看不懂         动物  水果      抽象关键字 : abstract     可以修饰类,方法,被修饰的类叫做抽象类 ,被修饰的方法叫做抽象方法       abstract        修饰方法:            public abstract void eat(); // 不能有方法体,需要用;结束        修饰类:            abstract class 类名             注意:                 1.类里面有抽象方法,类必须是抽象的,                 2.但是,抽象类里面不一定全都是抽象方法             抽象类不能实例化,就是不能new , 我们只能使用它的子类对象.            虽然不能被实例化,但是依然有构造方法,作用是,当子类创建对象的时候,父类可以初始化数据 .        子类的要求:            1.要么是抽象的            2.要么覆盖父类中所有的抽象方法    A:抽象类的成员特点        a:成员变量：既可以是变量，也可以是常量。        b:构造方法：有。                    用于子类访问父类数据的初始化。        c:成员方法：既可以是抽象的，也可以是非抽象的。    B:抽象类的成员方法特性：        a:抽象方法      强制要求子类做的事情。        b:非抽象方法     子类继承的事情，提高代码复用性。*/class AnimalTest{    public static void main(String[] args){    //  Animal  a = new Animal(); // 错误: Animal是抽象的; 无法实例化    //  a.eat();        System.out.println();    }}abstract class Animal { //错误: Animal不是抽象的,并且未覆盖Animal中的抽象方法eat()        public abstract void eat(); // 错误: 抽象方法不能有主体//  {//      System.out.println("吃东西 "); //  }    public void sleep(){        System.out.println("睡觉觉~~~~");    }}abstract class Cat extends Animal{    Cat(){        super();    }    // 错误: Cat不是抽象的, 并且未覆盖Animal中的抽象方法eat()//  public void eat(){//      System.out.println("用爪子吃鱼");//  }    eat();}

接口:
概述:类的扩展功能.
本质:一种规则.
特点:
1.格式:
定义:interface 接口名{}
使用: class 类名 implements 接口名{}
2.全部抽象方法
3.构造方法:没有
4.实例化:不能,但是可以实例其实现类
5.子类要求:
重写所有抽象方法
成员特点:
成员变量:常量
构造函数:无
成员方法:全部抽象
类与类,类与接口,接口与接口关系
如下:

/*    接口的特点:        1.接口内部有抽象方法,默认的有abstract修饰         2.接口就不能被实例化  ,不能new ,不能创建对象         3.类是可以实现接口的,实现了接口的那个类,是这个接口的子类 (接口是这个类的干爹 )         4.子类是可以实例化      成员的特点:        1.成员变量只能是常量  final 修饰 , static修饰        2.没有构造方法,因为子类有默认的构造或者继承了其他类的构造 .        3.成员方法 只能是抽象的,不可以有非常抽象的方法  ,默认abstract ,建议写上   */class USBTest{    public static void main(String[] args){    //  USB  u =new USB(); //  USB是抽象的; 无法实例化        Mouse m = new Mouse();        m.show();        //m.x = 20; //USBTest.java:23: 错误: 无法为最终变量x分配值        System.out.println( USB.x);         System.out.println(Mouse.x);    }}interface  USB{    final  int x =10; //默认有final , 默认有static      public abstract void connect();    public abstract void 输出();//{}}interface VGA{    public abstract void 显示 ();}class Mouse implements USB ,VGA {    public void show(){        System.out.println(x);    }    public  void connect(){         System.out.println("鼠标设备启动 ");    }    public  void 输出(){    }    public  void 显示 (){    }}

内部类:
概述: 类里面的类
成员内部类:
格式:
外部类名.内部类名 对象名 = 外部类对象.内部类对象;
举例:
Outer.Inner i = new Outer().new Inner();
如果private 修饰 内部类,那么就不能直接创建,提供公共的访问方式.(封装的思想 )
局部内部类:
问题:只能访问被final修饰的局部变量吗?
肯定的.局部变量和内部类的生命周期不同,所以使用final把局部变量变成常量.
匿名内部类:
前提:有一个接口或者类
本质: 对象– 实现了接口,或者继承了类的匿名子类的对象
如下:

/*    内部类概述:        如果在A类中,定义了一个B类,那么B类就是A类内部类      格式:        class Outer{            class Inner{            }        }    调用方式:        1.创建外部对象,通过成员方法来访问内部类         2.格式:            外部类名.内部类名 变量名 = new 外部对象().new内部对象();   */class OuterTest{    public static void main(String[] args){        //创建Outer,外部类对象,通过外部类成员方法,创建内部类对象          Outer out = new Outer();        out.method();        //直接创建内部类对象         Outer.Inner oi = new Outer().new Inner();        oi.show();    }}class Outer{    //内部类     class Inner{        public void show(){            System.out.println("Inner show ");        }    }    //写一个方法 ,去创建Inner对象,来调用Inner中的方法      public void method(){        Inner inner = new Inner();        inner.show();    }}

代码块:
静态:只有一次,类加载的时候
构造:执行多次,调用构造方法
局部:及时回收变量,提高运行效率

/*    代码块:{} 扩起来的部分    根据位置的不同    局码块:        作用限部代定变量的生命周期,提高内存的效率    构造代码块:        类中方法外,跟构造方法位置一样,你可以把构造方法中的相同代码,提取出来,在构造方法调用前,都会执行一次构造代码块语句.    静态代码块:static 修饰        类中方法外,在类加载的时候执行,并且只执行一次,给类的成员初始化数据用的.        */class DaiMaKuaiDemo{    public static void main(String[] args){        System.out.println();//      {//          int x =10;////          System.out.println(x);//      }//          System.out.println(x);        Person p = new Person("贾玲",28);        p.show();        Person p2 = new Person("瞿颖");        p2.show();    }}class Person{    String name;    int age;    static String country;        //静态代码块    static {        System.out.println("我是静态代码块");    //  age = 10;  //错误: 无法从静态上下文中引用非静态 变量 age        country = "中国姑娘";    }    Person(){}        //构造代码块    {        this.name = name;        System.out.println("我名字是fbb,这是构造代码块");    }    Person(String name,int age){        //this.name = name;        this.age = age;    }    Person(String name){        //this.name = name;    }    public void show(){        System.out.println(name +"---"+age +"---"+country);    }}

权限修饰符:
本类 同包 不同包子类 不同包其他类
private *
default * *
protected * * *
public * * * *