第一章：对象和封装

第一章：对象和封装

1.为什么要使用面向对象

面向对象就是采用现实模拟的方法和开发出现，实现了虚拟世界和现实世界的一致性， 符合人们的思维习惯。

2.设计面向对象分三步骤

第一步：发现类。

第二步：发现类的属性。

第三步：发现类的方法。

1.封装

1.面向对象的三大特征之一封装

封装可以被认为是一个保护屏障，将类的信息隐藏在类的内部，防止数据被其他类随意访问，封装增加了代码的安全性，让代码更容易理解和维护。

封装的多个权限控制符：

private：成员变量和方法只能在其定义的类中方法，具有类可见性。

protected：可以被同一个包中的类访问，被同一个项目中不同包中子类访问。

friendly：本类和同包子类可以访问。

public：任何地方可以访问，其他类通过对象名访问。

封装可用到关键字final,static

2.final

final 关键字可以修饰类方法和变量。

final修饰类的时候，这个类就不能被继承。

final修饰方法的时候，这个方法不能被重写。

final修饰变量的时候，这个变量的值只能赋值一次。

3.static

static可用来修饰方法和变量。

static一般称作为静态方法，在静态方法中不能访问类的非静态成员和方法。非静态方法就可以访问。

this和super

this表示当前类的对象引用，super表示调用父类成员。

4.构造方法及其重载

构造方法是用于对象初始化的，可分为有参无参构造方法显示方式非隐式和显示。

当没有自定义构造函数的时候，就有一个隐藏的无参构造函数
一旦手写构造函数，那么就不存在无参构造方法通过new关键字调用构造方法不能有返回值方法名也和类名一致。

重载的特点同一个类中相同的方法名不同的参数。

public class User{
    public int id;
    public String name;
    public User(){}//无参构造方法
    public User(int id,String name){//重载有参构造方法
        super();
        this.id=id;
        this.name=name;
    }
}

第二章：继承

java中 继承使用extends来实现，继承是面向对象的三大特性之一，是java实现代码重用的重要手段之一，java只支持单继承。

无法继承private修饰的属性和方法，无法继承父类的构造方法。

public class Pet{//企鹅类
    private String name;
    private int health ;
}
public class Dog extends Pet{//狗类继承父类企鹅类
    private String strain;
}

1.重写和继承关系中的构造方法

子类重写父类方法

在子类中可以根据需求对父类的方法进行重新编写。

重写方法和被重写方法必须具有相同的方法名。

重写方法和被重写方法必须具有相同的参数列表。

重写方法和返回值必须和被重写方法的返回值类型相同或是子类。

重写方法不能缩小访问权限。

2.继承关系中的构造方法

如果构造方法中有this或者super语句出现，super只能是第一条语句。

在一个构造方法中不能同时出现this和super语句调用构造方法。

public class Person {
	String name;//姓名
	public Person() {
		System.out.println("execute Person()");
	}
	public Person(String name) {
		this.name=name;
		System.out.println("execute Person(name)");
	}
    
public class Student extends Person{
	String school;//学校
	public Student() {
		System.out.println("execute Student()");
	}
	public Student(String name,String school) {
		super(name);//显示调用了父类有参构造方法，不会执行无参构造方法了
		this.school=school;
		System.out.println("execute Student(name,school)");
	}
}

3.抽象类和抽象方法

在java中用abstract来实现抽象类，抽象类中的方法也用abstract。

抽象类不能实例化，抽象类中可以有一个或者多个抽象方法。

抽象方法只有方法声明，没有方法是想，抽象方法的实现必须是子类。

public abstract class Pet {//抽象类
	private String name = "无名氏";
	private int health = 100;
	private int love = 0;
	
	
	public Pet() {
		this.health=95;
		System.out.println("执行宠物的无参构造方法");
	}
	public Pet(String name) {//有参构造方法
		this.name=name;
	}
	public String getName() {
		return name;
	}
	public int getHealth() {
		return health;
	}
	public int getLove() {
		return love;
	}
	public abstract void print() ;//抽象方法
}

如果定义一个子类就必须继承这个类的抽象方法，不然程序报错。

第三章：多态

多态不仅可以减少代码量，还可以提高代码的可扩展性和可维护性。

1.多态的特点

继承，重写，父类指向子类对象。

2.子类到父类的转换（向上转型）

Pet pet = new Dog();//子类到父类的转换

将一个父类应勇指向一个子类对象，称为向上转型，自动进行类型转换。

此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法，不是父类的方法。

此时通过父类引用变量无法条用子类特有的方法。

3.使用父类作为方法形参实现多态

public class Master {
	private String name;//主人名字
	private int money=0;
	public Master(String name,int money) {
		this.money=money;
		this.name=name;
	}
    public void feed(Dog dog) {
		dog.eat();
	}//主人给喂食
	public void feed(Penguin pgn) {
		pgn.eat();
    }
	public void feed(Pet pet) {
		pet.eat();
	}
}

使用父类作为方法形参，可减少代码量，提高代码可维护性和可扩展性。

4.父类到子类的转换（向下转型）

Pet pet=（Dog）pet;//还原子类向下转型

instanceof运算符语法

对象 instanceof 类或接口

public static void main(String[] args) {
		Pet pet = new Penguin("南南","Q妹");
		pet.eat();
		if (pet instanceof Dog) {
			Dog dog =(Dog)pet;
			dog.catchingFlyDisc();
		}else if(pet instanceof Penguin) {
			Penguin pgn = (Penguin)pet;
			pgn.swimming();
		}
	}

instanceof运算符通常和强制类型转换结合使用。

第四章：接口

接口是一个抽象类型，是抽象方法的集合，接口使用interface来声明。

语法：

public interface 接口名{}

接口中方法都会自动用public abstract修饰，即接口只有全局抽象方法，和抽象类一样，接口也不能实例化不能有构造方法。

接口之间可以通过extends实现继承关系，一个接口可以继承多个类，但接口不能，接口实现必须实现接口的全部方法，否则定义为抽象类。

修饰符 interface 接口名 extends 父接口1，父接口2{
    //常量定义
    //方法定义
}
class 类名 extends 父类名 implements 接口1，接口2{
    //类成员
}

接口的命名规则和类相同，接口中不能定义变量

1.接口和抽象类的区别

1.相同点：

都不能实例化

约束子类必须实现抽象方法，除非子类也是抽象类

2.不同点:

1、关键字：
抽象类：abstract
接口：interface
2、接口只能有抽象方法
抽象类可以有非抽象方法
3、接口不能有构造函数
抽象类可以有构造函数

2.java与c#接口区别

1.java中接口通过extends来继承父接口，类通过implements实现接口，c#通过果“：”来实现这两个功能。

2.java接口中的成员变量都是常量，自动用public static final 修饰，c#不予许有成员变量，当可以有属性。

3.java接口中属性和方法都可以使用public修饰，c#中默认为public，但不予许显示使用public修饰。

4.java接口中可以定义静态常量和方法，c#接口中不予许包含任何静态成员。