封装和继承

第一节：方法的参数传递、返回值

Java语言在给被调用方法的参数赋值时，采用传值的方式：

• 基本类型数据传递的是该数据的值本身。
• 引用类型数据传递的也是这个变量的值本身，即对象的地址(引用)，而非对象本身。

1.1 基本数据类型传递

//类
public class PassValue{
    public void change(int x){
        x = 100;
        System.out.println("方法中x==" + x);
    }
}

//类
public class Test{
	 public static void main(String[] args){
        PassValue pv = new PassValue();
        int x = 5;
        System.out.println("方法调用之前x=="+ x);
        pv.change(x);
        System.out.println("方法调用之后x==" + x);
    }
}

1.2 引用数据类型传递

数组、类、String(比较特殊特点：和基本类型一样)

public class PassValue2{
    int x ;
    public void change(PassValue2 obj){
        obj.x = 100;
        System.out.println(“方法中obj.x==” + obj.x);
    }
}

public class Test{
   public static void main(String[] args){
        PassValue2 p = new PassValue2();
        p.x = 5;
        System.out.println(“方法调用之前p.x==” + p.x);
        p.change(p);
        System.out.println(“方法调用之后p.x==” + p.x);
    }
}

1.3基本类型和引用类型作为方法的返回值

基本类型返回的实际数据

引用类型返回的是对象的地址

第二节：封装性

Java语言有三大特征：

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

1.1 封装的概念

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

封装成员变量两个步骤：

第一步： 添加private 修饰符

第二步： 添加get和set方法

1.2 private

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

1.3 get和set方法

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

语法：

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

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

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

/**
 * 人类
 * 	属性: 姓名 年龄 性别
 *  方法: eat study
 *  
 *  封装：（1）把成员变量变成私有的  (2)  添加get和set方法
 * @author wgy
 *
 */
public class Person {
	private String name;
	private int age;
	private String sex;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name=name;
	}
	
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		if(age>100||age<1) {
			this.age=18;
		}else {
			this.age=age;
		}
	}
	
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		if(sex.equals("男")||sex.equals("女")) {
			this.sex=sex;
		}else {
			this.sex="男";
		}
	}
	
	
	
	public void eat() {
		System.out.println(name+"开始吃饭...");
	}
	public void study() {
		System.out.println(name+"开始努力学习...");
	}
	public void show() {
		System.out.println("姓名:"+name+" 年龄:"+age+" 性别:"+sex);
	}
}

1.4 类设计原则

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

第三节：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关键字修饰的动态代码块，在类加载时自动执行，并只执行一次，初始化类（记住）

2.4 静态导入（了解）

用import static代替import，静态导入包是JDK1.5中的新特性。

一般我们导入一个类都用:import com...ClassName;而静态导入是这样:import static com...ClassName.* ;这里的多了个static，还有就是类名ClassName后面多了个.* ，意思是导入这个类里的静态方法和属性。

静态导入前

public class Demo {
    public static void main(String [] args){
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.toHexString(36));
    }
}

静态导入后

import static java.lang.System.out;
import static java.lang.Integer.*;

public class Demo {
    public static void main(String [] args){
        out.println(MAX_VALUE);
        out.println(toHexString(36));
    }
}

这种方法建议在有很多重复调用的时候使用，如果仅有一到两次调用，不如直接写方便。

第四节：继承性

4.1 继承的概念

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

4.2 继承的好处

• 实现代码的重用和扩展

• 模拟现实世界的关系

4.3 类的继承的使用

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

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

继承的类：子类，派生类

继承符合: is a 关系

4.4 语法：

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

? 编写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+"好好学习天天向上");
	}
}

编写动物类 (名字、颜色、品种)，打印方法，编写狗狗类（亲密度）和猫类（爱好）继承动物类，狗狗类和猫类都有打印信息的功能，狗狗有看家方法，猫类有玩球方法。

Animal类

/**
 * 动物类 
 *  (名字、颜色、品种)，打印方法
 * @author wgy
 *
 */
public class Animal {
	//昵称
	String name;
	//颜色
	String color;
	//品种
	String strain;
	
	//打印信息
	public void print() {
		System.out.println("动物信息: 昵称："+name+" 颜色:"+color+" 品种:"+strain) ;
	}
}

Dog类

/**
 * 狗狗类
 * @author wgy
 *
 */
public class Dog extends Animal{
	//亲密度
	int love;
	

	
	public void lookHome() {
		System.out.println(name+" 正在给主人看家...........");
	}
	
}

Cat类

/**
 * 猫类
 * @author wgy
 *
 */
public class Cat extends Animal{
	//爱好
	String hobby;
	
	/**
	 * 玩球
	 * 
	 */
	public void playBall() {
		System.out.println(name+"正在玩球..........");
	}
}

4.5 子类对象实例化过程

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

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

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

4.7 继承的特点

1）单继承：一个子类只能有一个父类,一个父类可以有多个子类
2）传递性：继承具有传递性

第五节：super关键字

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

this 表示当前对象的引用。

this用法：

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

? this.属性名

? 用法2：调用本类的方法

? this.方法名

? 用法3 ：调用本类中其他的构造方法。

? this(参数);

? 注意：1只能用在构造方法中，必须是第一条语句

? 2只能调用一次

5.2 super的概念

super表示当前父类对象的引用。

5.3 super的使用规则

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

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

3）super()：表示调用父类的构造方法，注意：super()必须是子类构造方法中第一条语句
子类中构造方法默认第一条语句会调用父类的无参数构造方法super()，也可以手动调用父类中带参数的构造方法

5.4 练习

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 print() {
		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.print();
	}
}

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

this和super的区别:

? (1) this表示当前对象的引用，super表示当前父类对象的引用

? (2) this.属性可以调用当前对象的属性包括继承的属性，super.属性可以调用父类的属性

? (3) this.方法() 可以调用当前对象的方法包括继承的方法，super.方法()可以调用父类的方法

? (4) this(参数) 调用本类中其他的构造方法，super(参数) 调用父类的构造方法

? (5) this(参数)和super(参数)只能用在构造方法中，必须是第一条语句，只能调用一次，不能同时使用。

第六节：包和访问权限

? 为了便于管理大型软件系统中数目众多的类，解决类命名冲突的问题，Java引入了包（package）。

在使用许多类时，类和方法的名称很难决定。有时需要使用与其他类相同的名称。包基本上隐藏了类并避免了名称上的冲突。

• 用package来声明包，package语句必须是java源文件中的第一条语句。(若无这条语句，则放置在无名包下)
• 在package语句中，用"."来指明包（目录）的层次。包对应着文件系统的目录层次结构。
• 一般使用公司或组织的域名的倒置+项目名或模块名来表示包名。
  • www.baidu.com 包名 com.baidu.oa
  • www.alibaba.com 包名 com.alibaba.pay

6.1 创建包

public class Employee {
    private String name;        //姓名
    private int age;                //年龄
    private double salary;     //薪水

  	public Employee(){
        
    }
    public Employee(String name, int age, double salary){    //构造方法
        this.name = name;
        this.age = age;
        this.salary = salary;
    }
  	//getter和setter省略
 } 

6.2 导入包

为使用定义在不同包中的Java类，需要import语句来引入所需要的类。

语法格式：

import package1[.package2…].类名

public class PackageDemo {	
    public static void main(String args[]){
        Employee employee = new Employee();
    }
}

注意：

? 要导入某个包中的所有类可以用：包名.*

? 例如：import java.util.*;

? 在同一包中的类可以直接互相引用，无需import语句。

6.2 访问权限

package a;
public class Person{
  	public String name;
  	protected int age;
  	char sex;
  	private double sal;
  	public Person(){}
  	public Person(String name, int age, char sex, double sal){
    	this.name = name;
      	this.age = age;
      	this.sex = sex;
      	this.sal = sal;
  	}
  	public static void main(String[]args){
    	Person p = new Person("张三", 12, ‘m‘, 5000);
      	System.out.println(p.name);
      	System.out.println(p.age);
      	System.out.println(p.sex);
      	System.out.println(p.sal);
  	}
}

package a;
public class Student extends Person{
  	public static void main(String[]args){
    	Person p = new Person("张三", 12, ‘m‘, 5000);
      	System.out.println(p.name);
      	System.out.println(p.age);
      	System.out.println(p.sex);
      	//System.out.println(p.sal);//同包子类中无法访问父类中私有成员
  	}
}

package a;
public class Demo{
  	public static void main(String[]args){
    	Person p = new Person("张三", 12, ‘m‘, 5000);
      	System.out.println(p.name);
      	System.out.println(p.age);
      	System.out.println(p.sex);
      	//System.out.println(p.sal);//同包类中无法访问父类中私有成员
  	}
}

package b;
public class Student extends Person{
  	public static void main(String[]args){
    	Person p = new Person("张三", 12, ‘m‘, 5000);
      	System.out.println(p.name);
      	System.out.println(p.age);
      	//System.out.println(p.sex);//不同包中子类中无法访问默认权限成员
      	//System.out.println(p.sal);
  	}
}

package b;
public class Demo{
  	public static void main(String[]args){
    	Person p = new Person("张三", 12, ‘m‘, 5000);
      	System.out.println(p.name);
      	//System.out.println(p.age);//不同包中不能访问受保护属性
      	//System.out.println(p.sex);
      	//System.out.println(p.sal);//不同包类中无法访问父类中私有成员
  	}
}

使用原则：

• 修饰类时：只能public 或 默认的
• 修饰成员变量和方法：可以使用public 、默认、protected 、private
• 局部变量不能访问权限修饰符。

第七节：方法重写

方法重载（overload）：

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

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

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

7.2 方法重写规则

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

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

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

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

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

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

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

封装和继承

原文：https://www.cnblogs.com/npeng/p/14338693.html