java面向对象 最重要的知识点

对象与引用

Java 语言中除基本类型之外的变量类型都称之为引用类型。
Java中的对象是通过引用对其操作的.

例如：
class Car{
String color;
String name;
}
Car ad= new Car();
通常把这条语句的动作称之为创建一个对象，其实，它包含了三个动作。

1）右边的“new Car()”，是以Car类为模板,调用Car类的构造函数,在堆空间里创建一个Car类对象。

2）左边的“Car ad”创建了一个Car类型引用变量。所谓Car类的引用，就是以后可以用来指向Car对象的对象引用。
3）”=”操作符使对象引用指向刚创建的那个Car对象。

Car类加载在内存中 存放在方法区

new Car()在堆空间里创建一个Car类对象

static关键字

static被称为静态 用来修饰类的属性 方法 代码块 内部类

随着类的加载而加载

优先于对象存在

修饰的成员 被所有对象共享

直接被类调用

静态属性是类的所有对象共享的，不管创建了多少个对象，静态属性在内存中只有一个。

静态成员不能访问非静态成员
非静态成员可以访问静态成员

代码块

代码块在类中声明，类似一个没有名称的方法体(代码块)，

代码块分实例块和静态块
实例块：每次创建对象时自动调用
{
//任何符合语法的Java代码
}
静态块：类加载时自动调用，仅一次，与是否创建对象无关。
static {
//任何符合语法的Java代码
}

package com.ff.day2;
/*
代码块 类似一个没有名称的方法体
实例块：每次创建对象时自动调用
静态块：类加载时自动调用，只调用一次，与是否创建对象无关
静态块 优先于 实例块执行
 */
public class SellTickect {
    {
        System.out.println("实例块1");
    }
    {
        System.out.println("实例块2");
    }

    static{
        System.out.println("静态块1");
    }
    static{

        System.out.println("静态块2");
    }
 public SellTickect(){
     System.out.println("text ");
 }
    public static void main(String[] args) {
      new SellTickect();
    }
}
/*输出结果
静态块1
静态块2
实例块1
实例块2
text */

包

包就是文件夹

包的作用

避免类重名

按照不同功能管理类

控制访问权限

package com.ff.day4;

import java.util.Date;
//import  java.sql.Date;不允许导入两个类名相同的类
//import 类的地址   在一个类中使用另一个包的类 通过import关键字导入
//java.lang包的类在使用时不需要导入

public class Test {
    public static void main(String[] args) {
        Date a=new Date();
        java.sql.Date b=new java.sql.Date(10);
        String s="";
    }

}

访问权限修饰符

public 公共权限 修饰类、属性、方法。可以被任意类访问
protected 受保护的权限 修饰属性、方法 可以被同包类访问，如果不是同包类，必须是该类的子类才可以访问。
(default)同包权限 修饰类、属性、方法。只能被同包的类访问
private私有权限 修饰属性、方法。 只能在本类中访问

封装

将类的某些信息隐藏在类内部 不允许外界

直接访问 而是通过该类提供的方法 来实现对隐藏信息的操作和访问

封装的好处

方便修改实现 方便加入控制语句 隐藏类的实现细节 只能通过方法访问

具体表现
属性使用private权限
方法使用public权限

public class Animal {
    private  String name;
    private  int age;
/*
将类的某些信息隐藏在类内部 不允许外界直接访问 而是通过该类提供的方法 来实现对隐藏信息的操作和访问

封装的好处

方便修改实现 方便加入控制语句 隐藏类的实现细节 只能通过方法访问
 */
    public Animal() {
        super();
        System.out.println("animal的构造方法");
    }

    public  void eat(){
        System.out.println("吃");
    }

    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;
    }
}

继承

继承是从已有的类中派生出新的类，新的类能吸收已有类的属性和行为，并能扩展新的能力

是实现代码可重用的根基，是提高代码可扩展性的主要途径

在JAVA中使用extends关键字来表示继承关系。
JAVA不支持多继承，单继承使JAVA的继承关系很简单，一个类只能有一个直接父类。
继承之后子类可以调用父类的所有非私有属性和非私有方法

当一个没有继承任何一个类时,jvm会默认让类继承Object类
Object是 java为所有类提供的基类

子类构造方法总是先调用父类构造方法,默认情况下调用父类无参构造方法
可以在子类构造方法的第一行，使用super关键字调用父类任意一个构造方法
如果用super,必须写在构造方法的第一句

public class Dog extends Animal{
        private  String whatDog;

    public Dog() {
        super();
        System.out.println("dog 的构造方法");
    }

    public void wang(){
            System.out.println("叫");
        }
    public String getwhatDog() {
        return whatDog;
    }
    public void setwhatDog(String whatDog) {
        this.whatDog = whatDog;
    }
}

super

super关键字代表父类的引用，
在子类构造方法中要调用父类的构造方法，注意：super语句只能出现在子类构造方法体的第一行。
用“super.成员变量名”来引用父类成员变量
用“super.方法名（参数列表）”的方式访问父类的方法。
与this的区别，this通常指代当前对象，super通常指代父类。

重写

当父类的实现方式满足不了子类的需求时 重写

重写的条件

方法名 参数相同

子类的访问权限大于等于父类

返回值相同

构造方法 静态方法不能重写

public abstract class Animal {
//被abstract 修饰 没有方法体
    public abstract void eat();
    public  abstract void sleep();
    public Animal(){

    }
    public  void paly(){
        System.out.println("animal play");
    }

}

public  class Dog extends Animal{

    public void eat() {
        System.out.println("狗吃肉");
    }


    public void sleep() {
        System.out.println("狗睡觉");
    }

}

类之间的关系 关联依赖

has a 关联 当一个类的对象作为另一个类的属性存在是 关联

use a 依赖 当一个类的对象作为另一个类的方法存在时 依赖

public class Person {
//    封装：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
    private String name;
    private int age;
    private  Phone phone;//关联关系 一对一   Phone的对象 作为person的属性存在
    private  Phone[] phones;//关联关系 一对多
    /*
    this关键字代表自身类的对象
    this关键字必须放在非静态方法里面
     */
    //依赖关系 person类中的方法用到了另一个类Dog
public void  eatWhat(Dog dog){
    dog.eat();
}

    public void setName(String name){
        this.name=name;
    }
    public void setAge(int age){
        this.age=age;
    }
    public int getAge(){
        return  age;
    }
    public  String getName(){
        return  name;
    }
}

抽象方法

抽象方法是一种特殊的方法：

只有声明，而没有具体的实现
抽象方法必须用abstract关键字进行修饰

抽象类，抽象方法，在软件开发过程中都是设计层面的概念。

也就是说，设计人员会设计出抽象类，抽象方法，

程序员都是来继承这些抽象类并覆盖抽象方法，实现具体功能。

/*
abstract的方法一定是抽象类
 但抽象类不一定有抽象方法
在顶层类中 方法的实现与子类大多数不同 就可以在顶层类中的方法就定义为抽象方法
 */

public abstract class Animal {
//被abstract 修饰 没有方法体
    public abstract void eat();
    public  abstract void sleep();
    public Animal(){

    }
    public  void paly(){
        System.out.println("animal play");
    }

}

接口

接口特性

1.接口不能实例化对象（无构造方法），但可以声明对象的引用。（多态性）
2.接口不是被类继承了，而是要被类实现,实现类必须重写接口的所有方法
3.一个类可以实现多个接口，但只能继承一个类。

4.接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字。
5.接口中每一个方法也是隐式抽象的，默认为public abstract 。
6.接口中声明的属性默认为 public static final 的；
7.多个类可以实现同一个接口。

8.与继承关系类似，接口与实现类之间存在多态性。
9.一个接口能继承其它多个接口。
10.当类实现接口的时候，类要实现接口中所有的方法。否则，类必须声明为抽象的类。

接口存在的意义

java中一个类只能有一个父类，但接口可以实现多继承。
从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。

接口的定义与使用

接口的定义：
[访问修饰符] interface 接口名称 [extends 其他的接口名1,….其他的接口名n] {
// 声明常量
// 抽象方法
}
接口的使用：
[访问修饰符] class 类名 implements 接口名1，接口名2……{ }
结合继承：
[访问修饰符] class 类名 extends 父类名 implements 接口名1，接口名2……{ }

package com.ff.day7;
/*
接口的定义
interface+接口名字{
   成员变量都是public  static  final
   所有方法都是 public  abstract
}
 */
 interface  Imessage{
    public  static  final  String info="this is a message";
    public  abstract  String getInfo();
}

interface IChannel{
    public abstract boolean connect();
}
/*
接口的使用
class+ 类名+ implements+ 接口名1，接口名2……{
        实现接口
}

 */
class Messageimpl implements Imessage,IChannel{
    public String getInfo() {
        if (this.connect()) {
            return "发送得到一个秘密的消息，有人胖了。";
        }
        return "通道创建失败，无法获取消息。";
    }
    public boolean connect(){
        System.out.println("消息发送通道已经成功建立。");
        return true;
    }
}
public class MyInterFace {
    public static void main(String args[]) {
        Imessage m = new Messageimpl();
        System.out.println(m.getInfo());
    }
}

final关键字

final 用于声明属性，方法和类
属性:定义就必须直接赋值或者在构造方法中进行赋值，并且后期都不能修改。
方法:子类里不可被覆盖。
类:不能被定义为抽象类或是接口,不可被继承。

package com.ff.day8;
//final 修饰的类不能被继承
/*
public final class FinalDemo {
 */
    //final 用于声明属性，方法和类 参数
public  class FinalDemo {
    final static int num=0; //直接初始化常量 使用final对属性赋值时建议用static 在内存中只有一份
   // final int count;
     public  FinalDemo() {

     }
   /* 在创建每一个对象时  对象中包含一个常量 必须在构造方法中赋值
   public FinalDemo(int a) {
        count=a;}
   */
    public  void test(final int b){
       //参数中的值不能被修改 int b=5;

    }
    //被final 修饰的方法不能被重写
    public  final void eat(){
        System.out.println("aaaaa");
    }
}

多态

同一种事物，在不同时刻表现不同的状态
多态存在的三个必要条件
要有继承（包括接口的实现）(前提条件)
要有重写(前提条件)
父类引用指向子类对象

多态环境下对成员方法的调用 编译看左边，运行看右边。

多态环境下对静态成员方法的调用 编译和运行都看左边。

多态环境下对成员变量的调用 编译和运行都看等号左边。

方法参数具有多态性 好处：提高代码的扩展性

向上转型的作用是：提高程序的扩展性。

向下转型的作用是：为了使用子类中的特有方法。

package com.ff.dt;

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 animal){
                animal.eat();
                //向下转型 父类类型转换为子类类型
            if (animal instanceof Dog){
                Dog dog=(Dog) animal;
                dog.play();
            }
            if (animal instanceof Cat){
                Cat cat=(Cat) animal;
                cat.catchMouse();
            }
        }
    }