第三次总结

面向对象

面向对象的本质是基于面向过程的。

面向过程的思想：

1）拿到一个需求分析步骤；

2）代码实现，中间代码中的逻辑判断；

3）最后进行测试。

面向对象的一个例子：

买手机：

先去手机店-----在手机店中挑选手机--------看手机配置等-------对手机进行讲价--------买到手机

面向对象是手机，面向过程是：先去手机店-----在手机店中挑选手机--------看手机配置等-------对手机进行讲价

面向对象的思想特点：
1）更符合我们生活中的思想行为习惯；
2）让复杂的事情简单化；
3）我们从执行者变为指挥者。
面向对象的三大特征：
封装，继承，多态

类和对象的关系

类：描述一组事物的属性和行为。
对象：描述具体的事物，通过代码体现
类名 变量名=new 类名（）；
对象名访问成员变量
对象名调用成员方法

Java中最基本的单元-----“类”

类是描述一组事物的属性和行为的集合! 
比如学生是一个类，
属性：姓名，年龄，性别，身高，年级，爱好...  ----对应类中的成员变量
行为：吃，喝，玩，乐。   ------对应类中的成员方法
代码如下：
class Student{
//成员变量----就是描述现实世界事物的属性(类中,方法外定义的变量)
	String name;//姓名
	int age;//年龄
	String sex;//性别
//成员方法---行为
	public void stady(){//学习
		System.out.println("我们正在学习");
	}
	public void sleep（）{//睡觉
	    System.out.println("我们正在学习");
	}
}
具体的学生事物----使用代码体现出来---就是 创建对象
    					类名 对象名  = new 类名() ; 固定格式
    					对象名.成员变量(属性) = 赋值; 注意数据类型
    					对象名.成员方法(行为) ; //有返回值,返回结果;没有返回值,直接单独调用
    	Student student=new Student();
		System.out.println("学生 姓名是:"+student.name+",年龄是"+student.age+",性别			是:"+student.sex) ; 
		//定义参数
		student.name=“杰斯”；
		student.age=22；
		student.sex=“男”
    System.out.println("姓名:"+student.name+",年龄:"+student.age+",
    			性别是:"+student.sex) ;
    			student.study() ;
    			String result = student. sleep() ;
    			System.out.println(result) ;
    			student.eat();

//定义一个手机类
public class Phone {

    //成员变量
    String brand ; //品牌

    int price ;//价格

    String color ; //颜色

    String memory ; //机身内存

    /*
      行为:成员方法 去掉了static
      callPhone(String name),name:某个人的名称
      sendMsg(String name), 给name 打发短信
       playGame():玩游戏
     */
    public void callPhone(String name){
        System.out.println("手机给"+name+"打电话了");
    }
    public void sendMsg(String name){
        System.out.println("给"+name+"在发短信");
    }

    public void playGame(String gameName){
        System.out.println("使用手机正在玩"+gameName);
    }

}
//测试类
public class PhoneTest {
    public static void main(String[] args) {
        /*
          建两个手机类对象,分别输出它门的对象名称
          以及重写给成员变量赋值,输出成员信息
         */
        //创建手机类对象
        Phone p = new Phone() ;
        System.out.println(p);
        p.brand = "小米12" ;
        p.price = 4999 ;
        p.color = "黑色";
        p.memory = "128G" ;
        //输出的p1访问的成员信息
        System.out.println(p.brand+"---"+ p.price+"---"+p.color+"--"+p.memory) ;
        //调用方法
        p.callPhone("张三") ;
        p.playGame("LOLM");
        p.sendMsg("李四");
    }
}

private关键字

特点：private访问的范围权限是最小的，仅限当前类中；
    被private修饰的成员变量/成员方法只能在当前类中访问，外界不能直接访问；
    可以间接通过公共访问来访问。
//定义一个类
class Demo{
     //公共的成员变量
    public int num ;
    //private修饰的
    private int num2 = 200;
    //私有的成员方法,也只能在本来访问
    private void method(){
        System.out.println("method Demo...");
    }

    //公共成员方法
    public void function(){
        method(); //公共访问间接访问私有本来私有方法
        System.out.println("function Demo");
    }
    //公共成员方法
    public void show(){
        System.out.println(num);
        System.out.println(num2);//num2私有的
    }
}

//测试类
public class PrivateDemo {

    public static void main(String[] args) {

        //访问Demo类中的num变量
        Demo d  = new Demo() ;
        d.num = 20 ;
        System.out.println(d.num);
        //System.out.println(d.num2);//此处访问不到
        d.show(); //公共访问
      //  d.method() ;//method方法是私有的,无法访问的!
        d.function();
    }
}

封装：将一个事物中的属性私有化（在所有成员变量加入关键字private），保证数据安全，对外提供的公共的访问方法来访问，并不能直接访问。
    公共方法：
    setXXX()getXXX()方法；称为：Setter and Getter

成员变量和局部变量的区别

1)书写位置不同

局部变量:在方法定义中或者方法声明上

成员变量:在类中方法外 (范围大)

2)内置中的位置不同

局部变量:在栈内存中

成员变量:在堆内存中

3)生命周期不同

局部变量: 随着方法调用而存在,随着方法调用结束而消失

成员变量:随着对象的创建而存在, (跟对象有关系:类名 对象名= new 类名();)

随着对象的创建完毕等待垃圾回收器空闲的时候回收掉,而消失!

4)初始化值不同

局部变量:要么先定义,后面初始化;要么直接直接初始化

在使用之前必须初始化,否则报错 "可能尚未初始化变量"

成员变量:存在系统默认初始化,可以不赋值,可以赋值,但是不一般不会直接赋值,都是通过对象名.成员变量名=赋值;

匿名对象

匿名对象：没有名字的对象。
  new 类名() ; 不需要在栈内存开辟空间,直接堆内存申请空间
匿名的好处:
1)在实际开发中,匿名对象不要多次,使用一次即可,使用完毕之后,立即就被垃圾回收器回收了。(因为没有栈内存变量指向堆内存地址)
2)匿名对象可以作为参数传递
3)匿名对象 从内存角度考虑,节省内存!

this关键字

 当局部变量隐藏了成员变量的时候,提供了一个关键字----叫"this",来区分成员变量和局部变量。
 this:代表的是当前类对象的地址值引用!
this.变量名---->变量名---->成员变量名 (对象.成员变量)
public class Student {
    //成员变量:私有化
    private String name ; //姓名  
    private int age ;    //年龄                                      
    private String gender ;//性别                                

    //提供对外的公共访问方法
  	//给姓名赋值
   // public void setName(String n){ 
    public void setName(String name){ 
        this.name = name ;  
    }
    //获取姓名
    public String getName(){
        return  name ;
    }

    //给年龄赋值
    public void setAge(int age){
       this.age  = age  ;
    }

    //获取年龄值
    public int getAge(){
        return age ;
    }

    //给性别赋值
    //public void setGender(String g){
    public void setGender(String gender){ //性别赋值
        this.gender = gender ; //局部变量g 赋值给成员变量  
    }
    //获取性别的值
    public String getGender(){
        return  gender ; 
    }
    //学习(),玩游戏()
    public void study(){
        System.out.println("我们在学习");
    }
    public void playGame(String gameName){
        System.out.println("某人正在玩"+gameName);
    }

}     

构造方法

构造方法：是一个特殊的方法
构造方法特殊性：
1)构造方法的方法名和类名相同
2)没有具体返回值类型
3)关键是连void都没有
构造方法是可以重载的!
构造方法的目的：
1）就是给成员变量赋值的
2）给成员变量赋值的方式:
(1)setXXX(局部变量)方法
(2)有参构造方法(局部变量...)
      //没有返回值类型,没有void
     public Student(){
         System.out.println("这是Student类的无参构造方法");
     }

       //带一个String类型的构造方法
    public Student(String name){//局部变量 name 需要传实际参数
       //  this.name = name ; //赋值了
        System.out.println("这是Student带一个String类型的有参构造方法,参数为"+name);
    }

    //带两个参数的有参构造方法
    public Student(String name,int age){
        System.out.println("这是Student带两个参数的有参构造方法,参数为"+name+"--"+age);
    }

    //带三个参数的构造方法
    public Student(String name,int age,String gender){
         //this.成员变量名 = 实际值
        //...赋值即可
        System.out.println("这是Student带两个参数的有参构造方法,参数为"+name+"--"+age+"---"+gender);
    }
}
构造方法的使用的注意事项
1)构造方法中,是没有返回值类型的,连void没有,不要随意定义构造方法..
2)当前我们的写的一个类(非测试类)中,没有提供任何构造方法的时候
系统会默认给我们提供无参构造方法;所以我们这俩天每次在写的时候,没有任何构造
方法,不会报错,但是我们学习了构造方法,以后永远给出"无参构造方法",继承中就会用到!
3)如果我们给了其中的有参构造方法,此时系统不会在提供无参构造方法,那么如果你使用
无参构造方法new 对象的话,就报错!,这也是为什么永远给出无参构造方法的原因之一!
给成员变量数据初始化----两种
1)通过无参构造方法+setXXX()赋值,通过getXXX()获取值
2)通过有参构造方法直接赋值,+getXXX()获取值

代码块

代码块:在java中使用{}包裹起来的就是代码块

分类:
局部代码块:在方法定义中的{},作用:限定变量的生命周期
构造代码块:在类的成员位置(类中方法外),{},作用:可以对成员的数据进行初始化
特点:如果一个类中有构造代码快,先执行的是构造代码块,然后执行构造方法
构造代码块的优先级高于构造方法 
静态代码块:
格式：
static{
}
静态的东西---优先于对象存在,那么静态代码块也一样,先执行
由于类就加载一次,所以静态代码块也就执行一次!!!
静态代码块>构造代码块>构造方法
每次执行构造方法之前,如果存在构造代码块都要先执行构造代码块!!!

继承 extends关键字

继承:将多个类的共享内容抽取出来放在一个独立的类中,那么这个独立的类和这多个类产生的关系----继承关系 ,关键字extends。
格式:
class 父类名{}
class 子类名 extends 父类名{
}
继承的好处:
1)提高了代码的复用性
2)提供了代码的维护性
3)类与类之间的继承关系,是"多态"的前提条件
继承的特点:
1)在Java中,类与类的继承关系,只支持单继承,不支持多继承!
2)虽然不支持多继承,但是可以多层继承!
格式:
class 父类名{}
class 子类名 extends 父类名{}
不能出现
class 子类名 extends 父类名1,父类名2{}...
在开发中要遵循“低耦合，高内聚”原则
耦合:指的是代码中的类与类的关系问题,关系越多,耦合性越强,后期维护起来难度大,一旦有个存在问题,都存在问题了!
内聚:指的就是某个类执行某件事情的能力!
一个类能够解决的,就不产关系最好(就不使用多个类来完成某件事情)
继承中成员的关系问题
类的成员:
成员变量
构造方法
成员方法
成员变量访问问题:
A)子类继承父类,子类的成员变量名称和父类的成员名称不一致的情况:
非常简单,分别访问即可!
B)  子类继承父类, 子类的成员变量名称和父类的成员名称一致的情况:
遵循"就近原则"
顺序:
1)先在子类的局部位置中找,如果有的话就使用;
2)如果在类局部位置中没有,在子类的成员位置中找,有就使用,
3)子类的成员位置没有,那么在父类的成员位置中找,如果有就使用,如果没有就报错了,说明当前整个就没有这个变量!
子类继承父类,成员变量名称一致,成员变量的访问问题
this.变量名:当前类的成员变量名
super.变量名---->父类的成员变量
super.方法名---->父类的成员方法
super:代表父类的空间表示(父类的对象的地址值引用)
在继承关系中,关于构造方法他们的访问:
1)子类继承父类,不能继承父类的构造方法,
但是可以通过super访问父类的构造方法
2)super访问：子类继承父类,子类的所有构造方法都会默认的访问父类的无参构造方法
super() ;可以隐藏不写'（原因：存在继承关系,需要让父类的数据 先初始化,因为我的子类可能用到父类的数据!而且super必须在第一行）。

子类继承父类,那么如果父类中的无参构造方法没有,那么会出现什么情况?如何解决呢?

子类继承父类,子类的所有构造方法都会默认super();访问父类的无参构造方法，无参都没有,子类的所有构造方法报错!
最基本的解决方案:
1)手动给出父类的无参构造方法
2)让子类的所有的构造方法间接访问父类的有参构造方法，只要让父类的数据进行初始化就可以!
3)在子类的所有构造方法中,只要有一个能够让父类的数据进行初始化即可，先在子类的有参构造方法中通过this():访问本类的无参，然后在本类的无参构造方法中,super("xx")访问父类的有参，或者是先访问本来的有参构造方法this(xxx),然后在本来的有参构造方法中通过super("xxx):访问父类的有参构造方法(不推荐)

成员变量访问问题:

子类继承父类,子类的成员变量名称和父类的成员名称不一致的情况:
分别访问即可!
子类继承父类, 子类的成员变量名称和父类的成员名称一致的情况:
遵循"就近原则"
顺序:
1)先在子类的局部位置中找,如果有的话就使用;
2)如果在类局部位置中没有,在子类的成员位置中找,有就使用,
3)子类的成员位置没有,那么在父类的成员位置中找,如果有就使用,如果没有就报错了,说明当前整个就没有这个变量!

static关键字

static关键字的特点:
1)被static修饰的变量或者方法---都称为 "类变量/类方法"因为他们是随着类的加载而加载,优先于对象先存在的!
2)static不能和this共存!
this:代表的当前类对象的地址值引用  ---创建对象了
this.变量名:访问当前类的成员变量 --非静态
this.方法名() ;访问当前类的成员方法 --非静态的
static:是要优先于对象存在,两个肯定不能共存(生命周期不同的!)
3)static基本的特点:共享共用,告诉我们,如果需求体现出共享共用,可以使用static修饰。
4)被静态修饰的变量/方法,推荐的访问方式:
类名.变量名;
类名.方法名();
也可以通过对象名.访问,但是不建议---这种访问方式,对象名.静态变量/方法--->直接点不出来(不建议这样写),但是可以变量/方法名补全可以访问
注意事项:
非静态的成员方法,既可以访问静态的,也可以访问非静态的
静态的方法，静态只能访问静态。

final关键字

 final："状态修饰符号"---最终的,无法更改的
修饰成员方法,这个方法不能被重写。
final的特点:最终的,无法更改的
1）修饰类,该类不能继承
2）修饰成员方法,该方法不能被重写
3）修饰成员变量,此时变量是一个常量---"自定义常量"
4）修饰的变量,只能被赋值一次,而且修饰成员变量,必须给一个常量值
5）修饰局部变量,赋值一次后,能够再次赋值了
实际的应用场景:结合 public static final 一块使用:自定义常量
public static final 基本数据类型 变量名 = 值 ;  
public static final int a = 10 ;
public static final 引用数据类型 变量名 = new 类名() ;  //运行时期常量,使用加载类的!
final Student s = new Student() ;//地址值不能在改变
             s = new Student() ; //错了,被final修饰

多态

多态：一个事物在不同时刻体现的不同形态。
多态的前提条件:
1)继承关系,必须存在,没有继承关系----谈不上多态
2)必须存在方法重写, 因为子类需要覆盖父类的功能
3)必须有父类引用指向子类对象-------->称为"向上转型"
格式:class Fu{}
       class Zi extends Fu{

//方法重写
 }
	 Fu fu = new Zi() ;
     fu.成员变量:
多态的成员访问特点：
1)成员变量(非静态)，编译看左,运行看左
2)成员方法(非静态)，编译看左,运行看右, 子类的方法将父类的方法覆盖了,所有使用的子类的功能
3)静态方法算不上方法重写---跟类相关,类名.方法名()，编译看左,运行看左
4)构造方法----访问---由于多态还是需要继承的,所以分层初始化
多态的特点:
1)提高代码的复用性(由继承保证)
2)提高代码的扩展性(有多态保证:父类引用指向子类对象)
多态的缺点:
父类引用指向子类对象
对象名.方法名() ---看父类中是否有这个方法,编译看左!
不能访问子类的特有功能
解决方式：
方式1:创建具体的子类对象，子类new子类对象
在堆内存中new,消耗内存空间,不建议(从内存焦点考虑)但是你非的使用,当前可以访问!
方式2:将父类的引用强转转换为子类的引用 :强转类型转换的格式'
                   Zi z = (Zi)f ;
               子类型 变量名 = (子类型)父的引用;
                向下转型

使用多态是容易发生的异常

ClassCastException:类转换异常
解决方案:改动代码---因为考虑内存中和当前接收的引用类型不匹配! 看内存的变化