Java 基础 封装继承

Java语言有三大特征：

• 封装：对外部不可见,隐藏对象的属性和实现细节。
• 继承：一个类继承另一个类的成员。
• 多态：每个对象表现的多样性。

1.1 封装的概念

什么是封装：在类中，对于不想被类外直接访问的成员变量，进行私有化，同时对外提供一个公有的方法为了访问私有的成员。

封装成员变量两个步骤：

a. 添加private 修饰符

b. 添加get和set方法

1.2 private

使用private访问权限实现成员变量的私有化，private修饰的成员变量就是私有成员变量，只能在类内部直接访问，类外不能直接访问

1.3 get和set方法

get方法表示访问私有属性的方法：

语法：

public 属性类型 getXxx(){
  	return 属性;
}

set方法表示修改私有属性的值的方法：

public void setXxx(参数类型 参数){
  	this.xxx = 参数;
}

1.4 类设计原则

• 成员变量(属性)私有化(用private修饰)，添加get和set方法
• 公开方法(用public修饰)

2：static关键字

static关键字只能修饰类成员，修饰成员变量和方法

2.1 静态属性

所有本类对象所共有且相同的一个属性，是类的公用变量，不会随着对象的改变而改变的属性。例如：圆周率。静态属性先于对象，不依赖于对象，可以直接通过类名直接访问（类名.属性名）。

public class Person{
    String name;
  	int age;
  	//人口总数
  	static int totalCount = 1300000000;
}
public class DemoPerson{
  	public static void main(String[]args){
    	System.out.println(Person.totalCount);//Person类中的totalCount属性是一个静态属性，可以直接通过类名访问
  	}
}

2.2 静态方法

所有本类对象所共有且相同的一个公共方法，属于类方法，先于对象的方法，不依赖于对象，可以直接通过类名直接调用（类名.方法名()）。

public class Person{
 	static int totalCount;
  	public static void calcTotalCount(){
    	System.out.println("统计人口方法");
      	totalCount=1350000000;
  	}
}
public class DemoPerson{
  	public static void main(String[]args){
    	Person.calcTotalCount();
  	}
}

使用静态属性和方法使用原则：

1如果这个变量或方法，不属于每个对象，属于整个类，就用静态

    2如果这个对象只有一个，那么类中的属性和方法都用静态的，一般工具类中的方法静态的  Arrays.方法名()

使用注意事项：

1 静态方法中可以直接访问静态变量，不能直接访问非静态变量。

2 非静态方法中可以直接访问静态变量和静态方法。

    3 静态变量存在方法区中静态域中

2.3 代码块

代码块分为：局部代码块、动态代码块、静态代码块

局部代码块：声明在方法中的代码块，执行时机与声明位置相关。（了解） 提前释放变量

动态代码块：又称构造代码块或实例代码块，声明在类体中的代码块，创建对象时自动执行一次，每创建一个对象就执行一次动态代码块。初始化工作。（了解）

静态代码块：使用static关键字修饰的动态代码块，在类加载时自动执行，并只执行一次。（记住）

3：继承

3.1 继承的概念

在原有类的基础上，产生一个新的类，在新的类中可以访问原有类中的非私有成员，并且可以添加一些自己独有的成员，这个过程叫做继承，简单理解一个类继承另外一个类。

3.2继承的好处

• 实现代码的重用和扩展
• 模拟现实世界的关系

3.3 类的继承的使用

使用extends关键实现两个类的继承关系

被继承的类：父类，超类，基类

继承的类：子类，派生类

继承符合 is a 关系

3.4 语法：

public class FatherClass{
	//属性
	//方法
}
public class ChildClass extends FatherClass {
	//属性
	//方法
}

案例1
编写Person类：

	属性有：姓名、年龄，出生日期

	方法有：showInfo();

编写Student类：

	属性有：姓名、年龄，出生日期、学校

	方法有：showInfo();

			study();

使用继承优化Student类。

public class Person {
	String name;
    int age;
	String birthday;
	
	public void showInfo() {
		System.out.println("姓名:"+name+" 年龄:"+age+" 出生日期:"+birthday);
	}
	
}

public class Student extends Person{
	
	String school;
	
	
	public void study() {
		System.out.println(name+"好好学习天天向上");
	}
}

3.5 子类对象实例化过程

• 1 先实例化父类对象
  • 默认调用父类默认构造方法
• 2 再实例化子类对象

3.6 不能被子类继承的成员：

1）私有成员：私有成员不能被子类继承

2）构造方法：父类中的构造方法不能被子类继承，但是会在子类的构造方法中调用（子类的构造方法中默认第一条语句是调用父类的默认构造方法）

3.7 继承的特点：

1）单继承，一个子类只能有一个父类,一个父类可以有多个子类

2）继承具有传递性

4：super关键字

4.1 super关键字：用法和this类似

this 表示当前类的对象

this用法：

1 调用本类的属性和方法，可以解决成员变量名和局部变量名同名问题。

2 调用本类中其他的构造方法。

	注意：如果调用其他构造方法，只能第一条语句

4.2 super的概念

super表示父类对象

4.3 super的使用规则

1）super.属性：表示访问父类中的属性，当子类中定义了与父类同名的属性时，若想在子类中访问父类的同名属性，需要使用super.属性访问

2）super.方法：表示调用父类中的方法，在子类中需要调用父类中没有被重写的方法时，需要使用super.方法调用

3）super()：表示调用父类的构造方法，注意：super()必须是子类构造方法中第一条语句

子类中构造方法默认第一条语句会调用父类的无参数构造方法super()，也可以手动调用父类中带参数的构造方法

练习

public class Animal {
	//属性
	String nickname;
	String color;
	String strain;
	
	//默认构造方法
	public Animal() {
		System.out.println("父类Animal的构造方法执行了..........");
	}
	
	//带参构造方法()
	public Animal(String nickname,String color,String strain) {
		this.nickname=nickname;
		this.color=color;
		this.strain=strain;
	}
	
	
	//打印方法
	public void printInfo() {
		System.out.println("本动物 昵称:"+nickname+" 颜色:"+color+" 品种:"+strain);
	}
}

public class Dog extends Animal{
	
	
	int love;
	//默认构造方法
	public Dog() {
		super();//调用父类的默认构造方法
		System.out.println("Dog子类的构造方法执行了");
	}
	//带参构造方法
	public Dog(String nickname,String color,String strain,int love) {
		super(nickname, color, strain);//调用父类的带参构造
		this.love=love;
	}
	
	
	public void lookHome() {
		System.out.println(nickname+"正在给主人看家....");
		System.out.println("昵称："+super.nickname);
		System.out.println("颜色:"+super.color);
		System.out.println("品种:"+super.strain);
		System.out.println("亲密度:"+this.love);
		super.printInfo();
	}
}

public class Test {
	public static void main(String[] args) {
		Dog afu=new Dog();
		afu.nickname="阿福";
		afu.color="黑色";
		afu.strain="哈士奇";
		afu.love=100;
		afu.lookHome();
		System.out.println("----------------------------------------");
		//调用Dog的带参构造
		Dog xiaohei=new Dog("小黑", "白色", "泰迪", 100);
		xiaohei.lookHome();
	}
}

拓展:

1：方法重写(覆盖)

方法重载（overload）：

1 同一个类中，方法名相同，参数列表不同（个数不同，类型不同，顺序不同）

2 和返回值，访问修饰符无关。

1.1 什么是方法重写：

在继承过程中，子类中从父类继承来的方法无法满足自己的需求时，可以在子类中对父类方法进行完善，这个完善过程叫做方法重写(override)，方法的重写相当于在子类中覆盖父类中的方法。

案例:

public class Animal {
	//属性
	String nickname;
	String color;
	String strain;
	
	//默认构造方法
	public Animal() {
		System.out.println("父类Animal的构造方法执行了..........");
	}
	
	//带参构造方法()
	public Animal(String nickname,String color,String strain) {
		this.nickname=nickname;
		this.color=color;
		this.strain=strain;
	}
	
	
	//打印方法
	protected Object printInfo() {
		System.out.println("本动物 昵称:"+nickname+" 颜色:"+color+" 品种:"+strain);
		return 10;
	}
}


public class Dog extends Animal{
	
	
	int love;
	//默认构造方法
	public Dog() {
		super();//调用父类的默认构造方法
		System.out.println("Dog子类的构造方法执行了");
	}
	//带参构造方法
	public Dog(String nickname,String color,String strain,int love) {
		super(nickname, color, strain);//调用父类的带参构造
		this.love=love;
	}
	
	/**
	 * 看家
	 */
	public void lookHome() {
		System.out.println(nickname+"正在给主人看家....");
	}
	/**
	 * 重写 :覆盖
	 * 1 方法名相同
	 * 2 方法参数  返回值类型必须相同
	 * 3 访问修饰符不能比父类严格
	 * 
	 * java特殊 1.7  返回值 可以和父类兼容就可以，必须是引用类型
	 */
	
	public String printInfo() {
		System.out.println("狗狗信息：昵称:"+super.nickname+" 颜色:"+super.color+" 品种:"+super.strain+" 亲密度:"+this.love);
		return "haha";
	}
}

1.2 方法重写的要求

访问权限 其他修饰符 返回值 方法名(参数列表)

 * 1 方法名、参数列表、返回值类型必须和父类相同
 * 2 访问修饰符不能比父类严格
 * 
 * java特殊 1.7  返回值可以和父类兼容就可以，必须是引用类型

1.3 方法的重写和方法的重载的区别

方法的重载：Overload，在同一个类中,方法名相同，参数类别不同，互为重载方法。

方法的重写：Override，在继承过程中，在子类中重写父类中继承来的方法，方法名相同，参数列表、返回值必须相同，访问权限不能比父类严格。

1.4 有关方法重写之后的调用：

只要在子类中重写了父类的方法，通过子类对象调用一定子类重写的方法。

2：构造方法的定义

2.1 构造方法的定义

构造方法也叫构造器，是指当实例化一个对象（创建一个对象）的时候，第一个被调用的方法

语法：

访问权限修饰符 类名(参数列表) {
						//方法体
}

普通方法：

访问权限修饰符 其他的修饰符 返回值类型 方法名（参数列表） {

}

注意：a.构造方法没有返回值类型,构造方法是在实例化对象的过程中自动调用的

                b.如果不写构造方法，系统会默认为我们提供一个无参的构造方法，如果添加了构造方法，系统不再提供默认的构造方法。

2.2 构造方法的调用

//演示构造方法的使用
public class Test 
{
	public static void main(String[] args) 
	{
		//创建动物
		Animal dog=new Animal();
		//使用属性
		dog.color="黄色";
		dog.nickname="旺财";
		dog.age=3;
		//使用方法
		dog.eat();
	}
}

public class Animal {
	//颜色
	String color;
	//昵称
	String nickname;
	//年龄
	int age;
	//默认构造方法
	public Animal() {
		
	}
	
	//吃
	public void eat() {
		System.out.println(nickname+"大口大口吃东西");
	}
}

2.3 构造方法和普通方法的区别

a.构造方法是在创建对象的过程中自动调用的，普通方法只能手动进行调用

b.构造方法没有返回值类型【注意区别返回值void】，普通方法的返回值类型要么是确定的类型，要么为void

c.系统会默认为我们提供一个无参的构造方法,普通方法只能手动添加

d.构造方法的方法名称必须和对应的类名保持一致

e.构造方法在创建对象的过程中就会执行，而且每个对象只执行一次，对于普通方法而言，只有在需要使用的时候才被执行，并且一个对象可以调用多次

2.4 构造方法重载

方法重载：同一个类中，方法名相同，参数类别不同

	 参数列表不同：个数不同，类型不同，顺序不同

	 和返回值修饰符无关

默认构造方法：只能创建对象，不能做任何初始化操作，如果实现创建对象时初始化属性，需要添加带参的构造方法，初始化对象的属性。如果一个类中有多个构造方法，这就是构造方法重载。

//演示构造方法的重载
//测试类
public class Test 
{
	public static void main(String[] args) 
	{
		//直接赋值
		/*
		Dog maomao = new Dog();
		maomao.name = "毛毛";
		maomao.age = 3;

		maomao.lookHome();
		*/

		//通过构造方法赋值
		Dog dahuang = new Dog("大黄",5);
		dahuang.lookHome();
	}
}

//实体类
public class Dog
{
	//成员变量
	String name;
	int age;

	//构造方法
	public Dog() {}
	//有参的构造方法，参数一般设置为和成员变量有关的参数
	public Dog(String n,int a) {
		//给成员变量赋值
		name = n;
		age = a;
	}
	/*
	public Dog(String n) {
		name = n;
	}
	*/

	//成员方法
	public void lookHome() {
		System.out.println(name + "看家");
	}
}

2.5 练习

//测试类
public class Test 
{
	public static void main(String[] args) 
	{
		//场景：富二代王思聪开着新买的白色宝马在马路上奔跑，很自豪的向他的新女友炫耀
		/*
		富二代类
		特征：姓名  有钱
		行为：开车，炫耀

		汽车类
		特征：颜色，品牌
		行为：奔跑

		女友类
		特征:姓名
		*/
		//1.创建一个富二代的对象
		RichMan wang = new RichMan("王思聪",true);


		wang.drive();
		wang.show();
	}
}

/*
富二代类
		特征：姓名  有钱
		行为：开车，炫耀车
*/
public class RichMan
{
	//成员变量
	String name;
	boolean hasMuchMoney;
	
	//默认构造方法
	public RichMan() {
        
    }
  	//带参构造方法
	public RichMan(String n,boolean is) {
		name = n;
		hasMuchMoney = is;
	}

	//成员方法
	public void drive() {
      	Car c=new Car();
      	c.brand="宝马";
		System.out.println(name + "开着豪车" + c.brand);
	}
	//展示
	public void show() {
		Car c=new Car();
      	c.brand="宝马";
      	GirlFriend gf=new GirlFriend();
      	gf.name="凤姐";
		System.out.println(name + "向" + gf.name + "炫耀豪车" + c.brand);
	}
}

/*
汽车类
		特征：颜色，品牌
		行为：奔跑
*/
public class Car
{
	//成员变量
	String color;
	String brand;

	//构造方法
	public Car() {}
	public Car(String c,String b) {
		color = c;
		brand = b;
	}

	//成员方法
	public void run() {
		System.out.println("一辆" + color + "的" + brand + "在奔跑");
	}
}

/*
女友类
		特征:姓名
*/
public class GirlFriend
{
	//成员变量
	String name;

	//构造方法
	public GirlFriend(){}
	public GirlFriend(String n) {
		name = n;
	}
}

3：this关键字

this：表示当前对象的引用。

3.1 this.属性

访问本类的成员属性

作用：为了区分成员变量和形参变量名一样的情况

成员变量默认值:

引用类型：null

基本类型：byte short int ：0

               long : 0L

	   float: 0.0f

	   double:0.0

           char :0

	   boolean:false

3.2 this.方法

访问本类的成员方法

3.3 练习

//演示this的使用
public class Test 
{
	public static void main(String[] args) 
	{
		//
		Cat maomao = new Cat("毛毛",10);
		maomao.show1();


	}
}

public class Cat
{
	String name;//昵称
	int age;//年龄
	String color;//颜色

	//3.this()
	public Cat() {
		System.out.println("无参的构造方法被调用");
	}
	//1.this.属性
	public Cat(String name,int age,String color) {
		this.color = color;
		this.name=name;
      	 this.age=age;
		System.out.println("带参2构造方法被调用");
	}



	//2.this.方法
	//普通方法
	public void show1() {
		//在本类中调用方法时，this可以省略
		this.show2();
	}

	public void show2() {
	}
}

3.4 this()（了解）

访问本类中的其他构造方法

注意：

	a.必须出现在构造方法中

	b.访问的是除了当前构造方法之外的其他构造方法

	c.具体访问的是哪个构造方法，取决于所传的参数

	d.只能书写在构造方法的第一条语句

	e.this()在同一个构造方法中只能出现一次

public class Test 
{
	public static void main(String[] args) 
	{
		System.out.println("Hello World!");
	}
}
public class Dog
{
	 String name;
	 int age;
	 int num;
	 String hobby;

	//提高代码的可读性，可维护性
	//构造方法
	public Dog() {
	}
	public Dog(String name) {
		this.name = name;
	}
	public Dog(int age) {
		this.age = age;
	}

	public Dog(String name,int age) {
		this.name = name;
		this.age = age;
	}
	public Dog(String name,int age,int num,String hobby) {
		this(name,age);
		this.num= num;
		this.hobby = hobby;
	}
}