JavaSE第四章面向对象

JavaSE第四章面向对象 一、面向对象 1、面向过程和面向对象都是语言设计思想 a、面向过程（procedure oriented programming，缩写pop）

关注于具体的流程，一步一步实现解决问题

例如：把大象装进冰箱，可以分为三步
    第一步，打开冰箱门
    第二步，把大象装进去
    第三步，关闭冰箱门

b、面向对象（object oriented programming，缩写oop）

先设计对现实中客观事物进行分类，创建出类（在类中定义具体的功能），创建出具体的对象，让对象去做具体的事情

例如：把大象装进冰箱，可以分为两类
     冰箱类{
    开门();
    装大象();
    关门();
}

面向对象无法取代面向过程，他们是相辅相成的，面向对象关注于从宏观上把握事物之间的关系，在具体到如何实现某个细节时，仍然采用面向过程的思维方式

面向对象如果离开了面向过程，就无法实现真正的落地，成为无源之水。

2、java类

类是对象现实事物的抽象，实际生活中，先有对象（具体存在），后有类

类是对同一类（具体存在的）共有的属性，行为的定义

类是一个模板，具体某个类来创建这个类的具体实现

类的结构：成员变量：类中的属性 名词

方法：类中的行为 动词

构造方法：用于创建对象

内部类：即在类体中声明的类

块：一段没有名称的代码块

类，可以分为三步
    1、发现类
        public修饰的类，类名必须与文件名一致，非public修饰的类，类名可以与文件名不一致
        [访问权限修饰符] [修饰符，abstract，final] class类{
    }
    2、定义类的成员变量（属性）   成员：类的成员，在类中定义   名词
    3、定义类的成员方法（行为/功能）   动词    

3、java对象

对象是类的实例，具体存在的客观事物，是可以拿来使用的 ，万事万物皆为对象

Car bm = new Car();
使用new关键字来创建对象；
new Car()    new以Car类为模板，在内存中创建对象
Car()        构造方法（默认有一个构造方法，方法名与类名相同）
Car bm       声明一个与构造方法名称相同的类型的变量
bm           表示一个具体存在的对象，可以使用
=            将创建的对象赋给左边的变量   

现实生活中先有对象后有类，而编程时先设计类后创建对象

4、类中的变量

从数据类型角度划分：基本数据类型变量：byte,short,int,long,float,double,char,boolean

                                    引用类型变量：类，数组，接口

从位置划分：成员变量，局部变量

成员变量：定义在类中，方法体之外

                  成员变量的数据类型可以为基本类型，也可以为引用类型

                  可以对成员变量进行初始化，如果不初始化，java会用默认值为其初始化（引用类型的默认值为null，整数默认值为0，浮点数默认值为0.0，Boolean默认值为false，char默认值为空格）

                   成员变量在创建对象时会从类中复制一份到对象中

                   成员变量可以被类中方法，构造方法和特定类的语句块访问

局部变量：在方法（构造方法）中或者代码块中

                  使用前必须赋值

                  数据类型可以是java中的任意类型

                  方法的参数也是局部变量

                  方法运行时局部变量创建，运行结束后局部变量销毁

5、类中的方法 成员方法：

        （非static）修饰，被对象调用，完成对象的功能

构造方法：用来初始化创建出来的对象，例如为对象中的属性赋值

         特点：构造方法的类名相同，且没有返回值，且不需要使用void修饰

                    每一个类中至少有一个默认无参的构造方法，每次创建对象时至少调用一个

                    如果显示的定义一个构造方法，默认的就失效了

                    如果类中无构造方法，默认会提供一个无参的

                    在无参的构造方法中为新建的对象用默认值初始化赋值

方法重载

        在同一个类中，有多个方法的名称相同，但参数不同

        如何区分方法：通过参数区分：参数的个数，类型，顺序不同

方法的重载与方法返回值类型无关，成员方法也可以重载

6、对象与引用

java中的数据类型：基本类型：byte,short,int,long,float,double,char,String

                                引用类型：除了基本类型都是引用（数组，String，自定义的类）

Person zs = new Person("张三"，22);
    new Person("张三"，22)； //在堆空间中创建并存的对象
    Person zs;              //在栈空间声明一个变量
    =           //把对象在内存中的地址赋给左边的变量，左边的变量只是持有对象的引用地址

7、this

this表示当前正在 *** 作的对象，在成员方法，构造方法中使用成员变量，使用this调用

值传递（形参数、值传递和引用传递类型是基本数据类型）：方法调用时，实际参数把它的值传递给对应的形式参数，形式参数只是用实际参数的值初始化自己的存储单元内容，是两个不同的存储单元，所以方法执行中形式参数值的改变不影响实际参数的值。

引用传递（形参数类型是引用数据类型参数）：也称为传地址。方法调用时，实际参数是对象，这时实际参数与形式参数指向同一个地址，在方法执行中，对形式参数的 *** 作实际上就是对实际参数的 *** 作，这个结果在方法中结束后被保留了下来，所以方法执行中形式参数的改变将会影响实际参数。

基本类型传递的是该数据值本身，引用类型传递的是对对象的引用，而不是对象本身

9、static关键字

静态：修饰属性，方法，代码块

          被static修饰的内容，随着类的加载而加载，优先于对象存在，被所有对象共享，可以通过类名调用

           类变量，和类一样，只有一份

          常量一般修饰为static

          static修饰的方法，称为类方法，静态方法不能使用非静态的成员变量，静态资源随着类先加载，非静态的随着对象的创建而加载

         非静态方法可以使用静态变量，非静态方法必须通过对象来调用，对象创建前先加载类

10、代码块

                类似一个没有名字的方法

代码块：实例代码块：在创建对象之后执行，调用构造方法之前执行，每创建一次对象，执行一次

静态代码块：在类加载的时候执行，只执行一次，多个静态按照先后顺序执行

类什么时候加载？main方法在哪个类中执行，这个类加载的

创建某个类的对象

调用某个类中静态属性，方法

11、包

为了更好地组织类，java提供了包机制，用于区别类名的命名空间（是类路径中的一部分 地址）

包的作用：避免重复类名

                  按功能管理类

                  控制访问权限

访问权限修饰符：用来修饰类，成员变量，方法，内部类，控制对其访问的权限

public         公共的                       类，成员变量，方法，内部类

protected    受保护的                   成员变量，方法，内部类

（default） 默认的（无）           类，成员变量，方法，内部类

private        私有的                      成员变量，方法，内部类

public在任何类中的都可以访问到

在同包其他类中只能访问公共的，受保护的，默认的

私有权限只能在自己类中访问，不能访问其他类

不同包不同类，公共权限依然能访问，默认的，受保护的不能访问

不同包子类中，可以访问父类受保护成员

包的命名规则：包名都小写

第一级：项目类型 ：com(商业) org（组织） edu gov

第二级：公司名称：Oracle sun huawei

第三级：项目名称：OA erp cms

第四级：项目模块：窗口/视图层 数据访问层 工具类

        细分子模块

12、import

导入其他包中的类 java.util.Date 类的全类名

                                           Date 简称

13、封装

将类的某些信息隐藏起来（用到访问权限修饰符来实现），不让在外部直接对其访问，可以通过一个特定的方法来对隐藏信息进行访问，便于控制

设计模式：解决某一类问题的解决方案（模式）

单例模式：让一个类在一个程序中，只能创建一个对象

将构造方法设置为私有权限，在其他类中不能随便使用

public class Fengzhuang {
    private static  Fengzhuang  name = null;
    private Fengzhuang(){
​
    }
    public static Fengzhuang getname(){
        if(name == null){
            name = new Fengzhuang();
​
        }
        return name;
    }
}

14、继承

子继承父 实现代码重用，扩展性好

什么情况下使用继承？    是同一类，什么是什么   is-a的关系
    大象 继承 动物      
    小汽车  继承 汽车  （小汽车除了继承父类的功能外，还可以扩展自己的功能）
    小学生  继承 学生
    
    大象类是动物类的子类，动物类是大象类的父类
    大象类是动物类的派生类，动物类是大象类的基类

使用extends关键字，一个类只能直接继承一个父类，继承之后子类就可以使用父类中非私有的成员，在子类中可以扩展子类特有的属性和方法

继承具有传递性（C 继承B，B继承A，那么C类就具有B类，A类的所有属性和方法）

当一个类没有显示的继承某个类，那么这个类默认继承object，object这个类是所有类的基类

继承中的构造方法

在创建对象子类对象后，调用构造方法是，从上向下的调用，先初始化父类信息，使用super（）在子类构造方法的第一行默认执行，调用父类无参的构造方法

super（）表示调用父类中无参构造方法，默认存储在，必须放在第一行

误区：super表示父类对象

在创建子类对象时，不会创建父类对象，只会将父类中的信息加载到子类对象中存储

方法的重写

在子类中对父类中的方法进行重写（覆盖）

具体语法：方法名相同，参数列表，返回值类型相同

访问权限修饰符等于或者大于父类的权限

@override（重写） 这是java中提供的一个注解标签（是一种标记，记号）

添加此注解的标签表示此方法是从父类重写过来的，就会对其语法验证

@overload（重载）

15、抽象类

抽象类: 也是类 抽象（概念）

抽象方法：只有声明没有实现

在一些比较靠顶层的类，它的实现与子类大多数不同，此时没有必要在顶层类实现，只需要声明功能即可

abstract修饰的方法是抽象方法，没有方法体

抽象类是用abstract修饰，抽象类可能包含了抽象方法，也可能没有包含抽象方法

如果一个类中没有包含足够的信息（抽象方法）来描绘一个具体的对象，这样的类就是抽象类

抽象类不能创建对象（因为其中包含抽象方法），其他功能与类相同（成员变量，成员方法，构造方法）

抽象类一般都是位于体系结构的上层，用来定义的功能

如果一个类继承了抽象类，要么重写抽象类中所有的抽象方法，要么也将此类声明为抽象类

16、多态

同一种事物，在不同的时候表现为不同的状态

条件：1、要有继承关系（类继承类，类继承抽象类，类实现接口）

           2、要有方法重写

           3、父类的引用指向子类的对象

public abstract class Animal {
     int age = 10;
    public Animal(){
​
    }
     public abstract void eat();
     public void sleep(){
         System.out.println("动物睡");
     }
     public static void play(){
         System.out.println("动物玩");
     }
​
}
public class Dog extends Animal{
    int age = 15;
    public Dog(){
    }
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}
public class Test {
    public static void main(String[] args) {
          Dog xh = new Dog();
​
          Animal a = new Dog();
                 a.eat();
                 a.sleep();
         
                 a.play();
​
        System.out.println(a.age);
    }
}
 

优缺点：

优点：父类引用表示子类对象，提升程序的扩展性

缺点：父类不能调用子类中特有的方法

多态转型：

自动转型：子继承父

向上转型 子类型 自动转为（上升为）父类类型

Animal dog = new Dog();

强制转型：

向下转型 父类型 转为 子类自己的类型

父类引用 instanceof 具体的子类类型

instanceof 判断父类引用实际表示的对象，是不是指定类型

public abstract class Animal {
    public abstract void eat();
    public void sleep(){
        System.out.println("动物睡觉");
    }
}
public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗啃骨头");
    }
    public void play(){
        System.out.println("狗会玩");
    }
}
public class Test1 {
    public static void main(String[] args) {
        Animal dog = new Dog();
        Animal cat =new Cat();
        Test1 t = new Test1();
        t.feedAnimal(dog);
        t.feedAnimal(cat);
    }
    public void feedAnimal(Animal a){
        a.eat();
        //判断Animal中实际传入的参数是什么
        if(a instanceof Dog){
            Dog dog = (Dog)a;
            dog.play();        
        }
    }
}

17、接口

USB接口 规范的定义（定义口的大小，如何传输数据....）

接口类似与抽象类（可以看作是一个更彻底的抽象类）

接口和抽象类，都是用于在顶层类，指定规范（设计功能）

JDK8之前，接口只能定义静态常量和抽象方法

JDK8以后，接口增加了静态方法和默认方法

interface 修饰的是接口

接口中没有构造方法，不能创建对象

接口也表示抽象（功能设计），也是需要其他类来实现的（继承）

子类需要使用 implements关键字

public interface Animal {
//    public static final int num = 10;
    int num =10;  //接口中的成员变量默认是静态常量
    void eat(); //接口定义抽象方法
//    public abstract void eat(); 
    
    public static void testStatic(){
        System.out.println("静态方法");
    }
    
    public default void testDefault(){
        System.out.println("默认方法");
    }
}
public class Dog implements Animal {
​
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}
public class Cat implements Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
public class Test {
    public static void main(String[] args) {
        Animal dog = new Dog();
        Animal cat = new Cat();
        Test t = new Test();
        t.feedAnimal(dog);
        t.feedAnimal(cat);
    }
    public void feedAnimal(Animal animal){
        animal.eat();
    }
}

一个接口可以继承多个接口

一个类可以实现多个接口

一个类只能直接继承一个类