Java面向对象总结

1.封装

1）作用：
属性封装(private)，即包装，不给外部看见。
2）被封装的属性必须用setter 和getter方法来设置和取得内容。
3）可以用setter设置属性,限制。(比如setAge，年龄限制在多少)

2.继承

继承是多态的前提，如果没有继承，就没有多态。
1）作用：
解决代码重复(重用)的问题。
2）格式：

class 子类 extends 父类{} 

扩充一个类已有的功能，比如子类扩充了父类所没有的属性和方法，实际上将父类定义的更加具体化。
比如：树和百年老树，人和超人。
父类表示的范围大，子类表示的范围小。

3）限制：
①Java不允许多重继承，但允许多层继承。(单继承局限)
即，一个子类只能有一个父类，一个父类可以有多个子类，子类的子类叫孙子类。

class A{} 
class B extends A{}
class C extends B{} #（多层继承，最多不要超过三层）

②子类只能继承父类的公有属性，private属性不能继承，只能利用setter或getter方法进行间接访问。
③实例化子类对象时会默认先执行父类构造(默认使用无参构造)，调用父类构造的方法体先执行，再实例化子类对象并且调用子类的构造方法。（对于子类构造来说，相当于隐含super()）

class A{
  public A(){
     System.out.println("A类构造方法！"); }}
class B extends A{
  public B(){
     System.out.println("B类构造方法！"); }}    //这里隐含了super()方法;
public class Test(){
  public static void main(String args[]){
	new B(); 
	}
} 

//执行结果 A类构造方法！  B类构造方法！
特别说明：当父类提供有无参构造方法时，是否编写super()方法没有区别。但是如果父类中没有
	无参构造方法时，则必须明确使用super()方法来调用父类指定参数的构造方法。

4） 在继承中super与this的用法与区别：
this用于调用属性 调用方法 调用构造方法。

super使用注意事项:	this使用注意事项
①super必须出现在子类的方法或构造方法中。	①通过this调用构造方法，仅仅在类的构造方法中才能使用。
②用于访问父类成员,例如父类的属性 方法 构造方法。	②函数参数或函数中的局部变量和成员变量同名时, 则需要用"this.成员变量"来引用成员。
③访问权限有限制,无法通过super访问private成员	③引用该函数当前对象时，直接用this。

			super()与this()的不同
						super:													this:
 1.功能      子类调用父类构造 父类方法 父类属性。              调用本类构造 本类方法 本类属性。
 2.形式      不查找子类,直接调用父类操作。                          先查找本类中是否存在有指定的调用结构，如果有则直接调用，没有则调用父类定义。
 3.特殊      ————                                        		表示本类的当前对象。
简单来说，就是super()认准父类，只查找父类。this()认准本类，优先查找本类，没有再调用父类。

	int num =20;
public void method(){
    int num =30;
    System.out.println(num);    //30，局部变量
    System.out.println(this.num);//20，本类的成员变量
    System.out.println(super.num);//10，父类的成员变量
}

3.抽象类

1）抽象方法：
就是加上abstract关键字，然后去掉大括号。(没有方法体)
2）抽象类：
有抽象方法且在class前加上了abstract的类。

public abstract class Animal{
    //这是一个抽象方法,代表吃东西,但是具体吃什么不确定
    public abstract void eat();
    //普通方法
    public void normalMethod(){
    }
}

有抽象方法的类一定属于抽象类，抽象类不一定有抽象方法。
3）作用：
利用抽象类可以明确定义子类需要覆写的方法。

4）如何使用：
①抽象类不能直接new。
原因：因为抽象方法没有方法体，而没有方法体的方法如何调用,不能调用如何产生实例化对象？
②必须用一个子类来继承抽象类。
即每一个抽象类一定要被子类所继承(使用extends)关键字，因为Java的单继承局限,所以一个子类只能够继承一个抽象类。
③抽象类的子类(子类不是抽象类)必须覆写抽象类中的全部抽象方法（强制子类覆写 );
④依靠对象的向上转型概念,可以通过抽象类的子类完成抽象类的实例化对象操作。

//抽象类
public abstract class Animal{
    //这是一个抽象方法,代表吃东西,但是具体吃什么不确定
    public abstract void eat();
}

//继承抽象类的子类
public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

//抽象类的使用
public class Demo {
    public static void main(String[] args) {
//        Animal animal = new Animal(); 错误写法！抽象类不能直接new
        Cat cat = new Cat();
        cat.eat();
    }
}

5）限制：
①抽象类不能使用final定义，因为抽象类必须有子类，而final定义的类不能有子类。
②抽象类中可以没有任何抽象方法，但只要是抽象类，就不能直接使用关键字new实例化对象。
③抽象类中依然可以定义内部的抽象类，而实现的子类也可以根据需要选择是否定义内部类来继承抽象内部类。
④外部抽象类不允许使用static声明，而内部的抽象类允许使用static声明，此时内部抽象类就相当于是一个外部抽象类，
继承的时候使用 “外部内.内部类”的形式表示类名称。（static 定义的是类）
⑤在抽象类中，如果定义了static属性或方法，就可以在没有对象的时候直接调用。（此时可以没有子类）

4.接口

1）接口是什么：
接口是一种约定(标准)和能力。它是引用类型，最重要的是其中的抽象方法。
interface声明接口，implements实现接口。
接口作为标准用于解耦合以及不同层之间的连接桥梁。

2）定义：
如果是Java 7，那么接口中有:
①常量（public static final可以省略）
常量不可变，且必须进行复制。
常量名称全部大写，且用下划线进行分割。(规范)
②抽象方法（public abstract可以省略）
实现类必须覆盖接口的所有抽象方法，除非实现类是抽象类。
Java 8:
③默认方法（public 可以省略）
主要作用：解决接口升级的问题，即如果想实现其他功能，就只需在接口里添加默认方法，而无需在多个实现类中覆盖重写新的方法。
接口的默认方法，可以通过接口实现类对象直接调用，也可以被接口实现类进行覆盖重写。
④静态方法（public可以省略）
注意：不能通过接口实现类的对象来调用接口当中的静态方法。
用法：接口名称.静态方法名(参数);
之前介绍static时就说过静态与对象无关，与类有关。
Java 9:
⑤私有方法
普通私有方法：解决多个默认方法之间重复代码的问题
静态私有方法：解决多个静态方法之间重复代码的问题

public interface ITest{
	public static final String MSG= "HELLO";
	//抽象方法
	public abstract void methodAbstract();
	public default void methodDefault(){
        System.out.println("默认方法");
    }
    public static void methodStatic(){
        System.out.println("静态方法");
    }
    //普通私有方法
    private void methodCommon(){
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }
    静态私有方法
    private static void methodStaticCommon(){
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }
}

3）使用：
①一个类的直接父类是唯一的，但是一个类可以同时实现多个接口，避免单继承局限。

public class X implements A,b

②接口的子类(如果不是抽象类)，必须要覆写接口中的全部抽象方法。
③接口的对象可以利用子类对象的向上转型进行实例化操作。
④如果一个子类既要继承抽象类又要实现接口，那么应该采用先继承（extends）后实现接口（implements）的顺序完成。

class X extends C implements A,B

⑤一个抽象类可以继承一个抽象类或者实现若干个接口。但是反过来，一个接口却不能继承抽象类。
一个接口可以使用extends关键字同时继承多个父接口。（接口多继承）

4）抽象类与接口的区别（优先考虑接口）

抽象类	接口
关键字：abstract	interface
子类使用： class 子类 extends 抽象类	class 子类 implements 接口，接口，……
关系：一个子类只能继承一个抽象父类，抽象类（或子类）可以实现多个接口。	而接口不能继承抽象类，但一个接口可以继承（用extends）多个父接口。
权限：可以使用各种权限	只能使用public权限
限制：单继承局限	没有单继承局限
子类：抽象类和接口都必须有子类，子类（非抽象类）必须要覆写全部的抽象方法。
实例化对象：都是依靠子类的向上转型进行对象的实例化。

抽象类要被子类继承，接口要被类实现。
一个接口能继承多个接口，一个类能实现多个接口。

5）接口的应用——工厂设计模式（解决代码耦合带来的问题）
代码编写标准：
①客户端（即主方法）调用简单，不需要关注具体细节；
②程序代码的修改，不影响客户端的调用，即使用者可以不去关心代码的变更。
解决new所带的的代码耦合度问题。

interface Person{
	public void act();}
class Eat implements Person{
	public void act(){
	System.out.println("吃饭");}}
class Drink implements Person{
	public void act(){
	System.out.println("喝水");}}

class Factory {				//工厂类
	public static Person getInstance(String className){
		if("eat".equals(className)){
			return new Eat();
		}else if("drink".equals(className)){
			return new Drink();
		}else {
			return null;}}}

public class Test{
	public static void main(String args[]){
		Person p = Factory.getInstance("eat");
	p.act();}}

本程序在客户端的操作上取消了new的使用,而使用 Facatory.getInstance()方法根据指定子类标记取得接口实例化，
这时客户端不再需要关注具体子类，也不需要关注Factory类是怎样处理的只需要关注如何取得接口对象并操作。

2.——代理设计模式
代理设计是指一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理。
代理设计模式的格式：①接口②真实主题 ③ 代理主题 ④主类(客户端)

interface Network{						//接口
	public void browse();
}
class Real implements Network{				//真实主题
	public void browse(){
		System.out.println("上网浏览");
	}
}
class Proxy implements Network{				//代理主题
	private Network network;
	public Proxy(Network network){			//设置代理的真实操作
		this.network=network;			//设置代理的子类
	}
	public void check(){					//与具体上网相关的操作
		System.out.println("检查用户是否合法");
	}
	public void browse(){						
		this.check();					//可以同时调用多个与具体业务相关的操作
		this.network.browse();				//调用真实上网操作
	}
}
	
	public class Test2{
		public static void main(String args[]){
			Network net =new Proxy(new Real());	//定义接口对象实例化对象，同时传入代理的真实操作
			net.browse();			//客户只关心上网一个功能
	}
}

在本程序中，真实主题实现类完成的只是上网的最基本功能，而代理主题要做比真实主题更多的相关业务操作。

	区分 对象 类 抽象类 接口 继承 实现（P253）

回答：接口是在类之上的标准。

5.多态性

1）多态是什么：
同一个引用类型，使用不同的实例而执行不同操作。(一个对象拥有多种形态，如小明是一个学生(学生形态)，也是一个人(人类形态))

2）多态的好处：
让代码更加的灵活。

3）多态性：
●方法的多态性：重载与覆写；
重载：同一个方法名称相同，根据不同的参数类型及个数完成不同的功能。
覆写：同一个方法名称相同, 根据实例化的子类对象不同,所完成的功能也不同。

●对象的多态性：父子类对象的转换。（看new的是谁）
向上转型：子类对象变为父类对象。
向下转型：父类对象变为子类对象。

向上转型格式 ： 父类 父类对象 = new 子类实例
	自动转换  A a= new B();
向下转型格式:子类 子类对象 = (子类) 父类实例 
 	强制转换   B b = (B) a;（父类调用子类方法)
向下转型前必须发生向上转向才可以向下转型。（int和long)

4）多态产生的条件：
继承、方法重写、父类的声明和子类的实例化。

5）举例：
动物 a = new 猫();
对象a是一只猫，也属于动物。
a.eat();//对象a可以使用动物中的eat或其他方法，但不可以调用子类猫中的方法。（除非子类方法覆写父类方法）
如果想调用子类特有的方法，借助向下转型。

//父类动物
public abstract class Animal {
    public abstract void eat();
}

//子类猫
public class Cat extends Animal{
    public void eat(){
        System.out.println("猫吃鱼");
    }
    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}

//子类狗
public class Dog extends Animal{
    public void eat(){
        System.out.println("狗吃肉");
    }
    public void Play(){
        System.out.println("哈士奇逗你玩");
    }
}

//主方法
public class Demo2 {
    public static void main(String[] args) {
        Animal animal = new Cat();//向上转型
        animal.eat();//猫吃鱼
//        animal.catchMouse();  //错误写法
        //向下转型，进行还原操作
        Cat cat =(Cat) animal;
        cat.catchMouse();

//        Dog dog =(Dog) animal;//错误写法。报错java.lang.ClassCastException，类转换异常.
    }
}

6）总结：
对象向上转型的主要意义在于参数的统一，向下转型指的是父类调用子类的个性化操作方法。
7）instanceof关键字：
判断某个对象是否是指定类的对象。
格式：对象 instanceof 类
返回 boolean型 （判断向下转型)

if (animal instanceof Dog){
    Dog dog = (Dog) animal;
    dog.Play();
}
if(animal instanceof Cat) {
    Cat cat = (Cat) animal;
    cat.catchMouse();
}

6.final关键字

1）final：
在Java中final被称为终结器，在Java里面可以使用final定义类，方法和属性。
2）作用：

类	使用final定义的类不能再有子类，即：任何类都不能继承以final声明的父类。
方法	使用final定义的方法不能被子类所覆写。（最终方法）
属性	使用final定义的变量就成为了常量，常量必须在定义的时候设置好内容，并且不能修改。(常量名称使用全部大写的形式)

3）全局变量：
public + static + final 联合定义的常量。

public static final String MSG="HELLO"; (公共常量)

7.修饰符

8.包——解决类的同名问题

包的作用：
1）文档分门别类，易于查找。
2）易于管理。
3）不同内容的文档可以放在不同的袋子中，拥有相同的名字，避免冲突。

创建包：使用package声明包，以分号结尾
包命名规范：包名由小写字母组成，不能以圆点开头或结尾

分别创建包和类：
创建项目→创建包→创建类

创建类的过程中创建类所在的包
创建项目→创建包和类

导入包：为了使用不在同一包中的类，需要在Java程序中使用import关键字导入这个类