Java基础知识——09

目录

​编辑

一、封装性

二、继承

1.继承的概念

2.继承的特点

三、不可继承性

四、继承中的重写

五、super关键字

---

一、封装性

面对对象的三大特征：封装、继承与多态

封装步骤：属性私有化、用set/get进行赋值与取值

解决：当逻辑没问题，但是数据不合理时使用

使用时：在使用时set方法与get方法是配套使用的，有了set赋值就要相应的有一个get取值返回值的内容

class Student{
	private String name;//1.进行属性的私有化
	private int    age;  //只能在当前类中进行使用，从源头上规避属性的调用
	
	public Student() {}  //无参构造
	public Student(String name,int age) {
		this.name = name;
		this.setAge(age);  //this调方法
	}
	public void eat() {
		System.out.println("姓名："+name+";年龄："+age+"正在吃早餐");
	}
	public void setName(String name) {
		this.name = name; 
	}
	public String getName() {
		return name;
	}
	
	//set方法的规范：set+属性名首字母大写;参数名与属性名一致
	public void setAge(int age) {
		if(age<=0) { //如果值有问题，则设置为18
			this.age=18;
		}else {
			this.age = age;
		}
	}
	//get方法的规范：get+属性名首字母大写；返回属性值
	public int getAge() {
		return age;
	}
}
public class work1_test {
	public static void main(String[] args) {
		Student st = new Student();
		st.setName("杨利伟");
		st.setAge(19);  //赋值
		/*
		st.age  = -2;
		if(st.age<=0) {
			st.age = 18;
		}*/
		
		System.out.println(st.getAge());  //取值
		
		st.eat();
		//st.age = -6;  //属性+private权限
		
		//------带参构造的安全性------
		Student st2 = new Student("张无忌",-22);
		st2.eat();
		
	}
}

二、继承

1.继承的概念

程序中的继承是指：类与类的关系，子类继承父类的属性和方法

祖宗类：Object

重合点越多越接近父类，重合点越少越接近祖宗类

比如说狗属于动物类，香蕉属于水果类

共性的抽取：将共有的特性与行为抽取出来，比如说动物类都会吃，鸟类都会飞等，能提升复用性，减少代码量，提升扩展性

class Animal{
	String name;
	public void eat() {
		System.out.println(name+"正在吃");
	}
}
class Dog extends Animal{
	String color;
	public void run() {
		System.out.println(name+"正在跑");
	}
}
class Fish extends Animal{
	String color;
	public void swim() {
		System.out.println(name+"正在游");
	}
}
class Bird extends Animal{
	String color;
	public void fly() {
		System.out.println(name+"正在飞");
	}
}

public class extend {
	public static void main(String[] args) {
		Dog dog = new Dog();
		dog.name = "来福";
		dog.color = "白色";
		dog.run();
		dog.eat();
		Fish fish = new Fish();
		fish.name = "小金";//这里不能加颜色，否则会报错
		fish.color = "金色";
		fish.swim();
		fish.eat();
		Bird bird = new Bird();
		bird.name = "小小";
		bird.color = "黑色";
		bird.fly();
		bird.eat();
	}
}

2.继承的特点

没有多继承，但是有多级继承

孙子类可以调爷爷类的属性，因为有多级继承，也可以调用自身以及父类的方法也可以调用爷爷类和父类的属性，但是父类不可以调用子类的方法

class GrandFather{
	String name;
	public  void haveCar(){
		System.out.println(name+"爷爷有一座房");
	}
}
class Father extends GrandFather{
	public void haveMoney() {
		System.out.println(name+"爸爸有很多车");
	}
}
class Son extends Father {
	public void haveToy() {
		System.out.println(name+"有玩具车");
	}
}

public class extend2 {
	public static void main(String[] args) {
		Son son = new Son();
		son.name = "小米";
		son.haveToy();
		son.haveMoney();
		son.haveCar();
	}
}

三、不可继承性

有三种可能是不可继承的，一是私有的成员（属性和方法）没有继承性，构造方法没有继承性以及不同包的default权限也没有继承性

在java中权限范围的大小： public>protected>default>private

private：私有权限，在当前类中可以访问，私有权限，在同包不同类中不能访问，私有权限，在不同包的子类中不能访，私有权限，在不同包不同类中不能访问

default：默认权限，在本类中可以访问，默认权限，在同包不同类中可以访问，默认权限，在不同包的子类中不能访问，默认权限，在不同包不同类中不能访问

protected：保护权限，在本类中可以访问，保护权限，在同包不同类中可以访问，保护权限，在不同包的子类中可以访问，保护权限，在不同包不同类中不能访问

public：公开权限，在本类中可以访问，公开权限，在同包不同类中可以访问，公开权限，在不同包的子类中可以访问，公开权限，在不同包不同类中可以访问

四、继承中的重写

概述：在继承关系中，子类的方法和父类完全一致；权限大于或等于父类

应用场景：当父类的方法不适用子类时，子类可重写父类的方法

重写一般都有注解：重写的注解，表示当前方法是重写方法，如果不是则报错

class GrandFather{
	public void car() {
		System.out.println("爷爷有辆老爷车");
	}
}

class Father extends GrandFather{
	@Override
	public void car() {
		
		super.car();
		System.out.println("爸爸有一辆跑车");
	}
}

class Son extends Father{
	@Override
	public void car() {
		super.car();
		System.out.println("我有一辆玩具车");
	}
}

public class work4 {
	public static void main(String[] args) {
		new Son().car();
		
	}
}

五、super关键字

super：父类对象，应用方面表示调用父类的成员(调属性，方法，构造方法)

this与super的区别

属性：this调当前对象的属性，若当前对象没有属性，根据继承性可调父类属性，而super直接调父类的属性

方法：调当前对象的方法，若当前对象没有方法，根据继承性可调父类方法，而super直接调父类的方法

并且super可以调父类的构造方法，并且在子类构造方法实现的首句，默认会有super（），调父类无参构造，在调用子类构造方法时，首句会有super()的设计是因为实例化子类资源时，需要将父类资源也进行实例化；继承的特性本质就是子类资源+父类资源

class A{
	String name = " 凤姐";
	public void show() {
		System.out.println("父类的show");
	}
}

class B extends A{
	String name = "刘亦菲";
	public void test() {
			System.out.println(name);
			System.out.println(this.name);
			System.out.println(super.name);
		}
		@Override//重写的注解
		public void show() {
			super.show();
		System.out.println("子类的show");
	}
}

public class Test1 {
	public static void main(String[] args) {
		new B().test();
		new B().show();
	}
}

class AA{
	public AA() {
		System.out.println("父类AA无参构造");//注意：无参构造的顺序
	}
	public AA(int a) {
		System.out.println("父类AA有参构造");
	}
}

class BB extends AA{
	public BB() {
		super();//出现在构造方法的首句
		//super(66);//父类AA无参构造，子类BB有参构造
		System.out.println("子类BB无参构造");
	}
	public BB(int a) {
		//this();
		System.out.println("子类BB有参构造");
	}
}

public class test {
	public static void main(String[] args) {
		//new BB();//父类AA有参 子类BB无参
		new BB(66);
	}
}