JavaSE学习笔记 Day10

JavaSE学习笔记 Day10

个人整理非商业用途，欢迎探讨与指正！！
« 上一篇

---

---

···

九、面向对象三大特征

9.1封装

作用:保护,包装,不为外界所干扰
程序中的封装,不被外界直接访问

9.1.1怎样封装

对属性使用private关键字
private 私有的,只能被本类所访问的

//	封装
private double money;//私有属性,只能被本类所访问

9.1.2私有属性的访问权限

默认情况下,私有属性无法被外部直接访问
可以指定共有的方法,为私有属性提供外部访问的权限

封装就是对一个属性进行私有设置,并且添加两个共有方法,为了访问和赋值使用(两个共有方法是可以选择是否添加)
Xxx:是属性的首字母大写
getXxx:取值使用
public 类型 getXxx(){
return xxx;
}
setXxx:赋值使用
public void setXxx(类型 xxx){
this.xxx = xxx;
}

//	封装
private double money = 1000000;//私有属性,只能被本类所访问

//	获取余额的方法
public double getMoney() {
    return money;
}

//	设置存款方法
public void setMoney(double money) {
    this.money = money;
}

9.1.3封装的作用

1.保护属性不能被外界直接访问
2.可以过滤有效数据

public void setName(String name) {
    //		过滤用户名
    if(name == null || "".equals(name) || name.length() > 5) {
        this.name = "无名氏";
        return;
    }
    this.name = name;
}
public void setAge(int age) {
    if(age > 150 || age < 0) {
        //			若年龄不合理,我们就赋值为18
        this.age = 18;
        return;
    }
    this.age = age;
}

9.1.4JavaBean的设计

JavaBean就是Java实体类
业务相关的命名
实体类:JavaBean,Vo,POJO等…
实体可分为两种:1.数据承载实体 2.业务逻辑实体

数据承载实体具体要求:
1.所有属性私有化
2.私有属性提供对外公开的set/get方法
3.提供有参和无参的构造方法

上述的所有方法,在esclipse可以使用alt+shift+s快速生成

package com.qf.pojo;

public class Student {
//	对如下属性进行封装
//	为属性赋值的方法:1.有参构造 2.set方法
	private int stuNo;
	private String name;
	private String gender;
	private String hobby;
	public int getStuNo() {
		return stuNo;
	}
	public void setStuNo(int stuNo) {
		this.stuNo = stuNo;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
	public String getHobby() {
		return hobby;
	}
	public void setHobby(String hobby) {
		this.hobby = hobby;
	}
	public Student(int stuNo, String name, String gender, String hobby) {
		this.stuNo = stuNo;
		this.name = name;
		this.gender = gender;
		this.hobby = hobby;
	}
	public Student() {
		
	}
	
}

9.2继承

9.2.1生活中的继承

一方将东西给另一方

9.2.2程序中的继承

两个类之间若满足"is a"的关系,就符合继承关系
将生活中的赠与得使用代码去体现出来
例如:Dog is a Animal 成立 Cat is a Animal 成立
Animal是父类 Dog和Cat是子类

9.2.3父类的选则

现实中有很多的继承关系,都满足"is a"的关系
例如:狗是一种动物,狗是一种生物,狗是一种物质
从上述例子来看,多个类别都可以作为狗的父类,我们在开发时需要找到最符合最合适的父类
功能越详细重合点越多,越接近于父类
功能越粗略重合点越少,越接近于Object类(java中所类的父类)

9.2.4父类的抽象

根据多个有相似特征和行为的类,进行抽取的
定义父类的作用是为了代码重用

public class Animal {

	private String name;
	private int age;
	private String gender;
	private String hobby;

public class Cat extends Animal{

//	扩展自己的属性
	private int teeth;

public class Dog extends Animal {

//	额外扩展狗狗的种类
	private String type;

public static void main(String[] args) {
    Cat cat = new Cat();
    //		cat调用如下方法都是从父类中继承来的
    cat.setName("咪咪");
    cat.setAge(2);
    cat.setHobby("玩");
    cat.setGender("男");
    //		可以额外添加自己的属性
    cat.setTeeth(28);

    Dog dog = new Dog();
    //		Dog没有继承Aniaml,那么就无法得到父类的赠与
    dog.setName("大黄");
    dog.setType("拉布拉多");
}

9.2.5继承的作用和特点

继承就是类与类之间赠与得的过程
作用:减少冗余代码,提供代码的重用
语法
子类 extends 父类

子类继承父类时,可以继承父类的属性和方法
子类中可以拥有自己独有的方法和属性(在父类的基础上进行扩展)
java中是单继承的,一个子类只能有一个父类(一个父类可以拥有多个子类)
 java中是存在多继承关系的,但是类与类之间只有单继承
默认情况下,所有的类都继承自Object类,
 例如:public class Animal{} 等价与 public class Aniaml extends Object{}
 可以说所有的类都直接或者间接继承自Object类

9.2.6不可被继承的内容

继承关系中不是父类中的所有内容都无条件被子类继承,有一些内容无法被继承
1.构造方法
2.父类中私有的属性和方法
3.默认的访问权限修饰符,跨包不能被继承

9.2.7访问权限修饰符

private 私有的 修饰属性
[default] 默认的,缺省的,友好的(没有任何的修饰符)
protected 受保护的
public 公共的 修饰方法

访问权限修饰符	本类	本包(不同类)	跨包子类	其他
private	√
默认的	√	√
protected	√	√	√
public	√	√	√	√

9.2.8方法重写

方法覆盖
子类和父类中有相同方法标签的,被称为方法覆盖/重写
 方法标签:方法名和参数列表
重写的特点:
 相同标签:方法名相同,参数相同,返回值相同(或兼容),子类的访问权限修饰符要比父类的更宽泛
重写的作用:
 因父类的方法无法满足子类的需求,需要将继承来的方法进行重写

注解:@Override 建议添加到重写的方法之上
 该注解可以检查重写方法是否正确,若正确则不报错,若不正确则报错

注意:在继承关系中的同名方法不是重写就是重载
不能被继承的方法,是不能被重写的

package com.qf.test03;

public class Animal {

//	没有明确的吃的种类
	public void eat() {
		System.out.println("就是吃,也不知道是谁吃...");
	}
	
	public static void main(String[] args) {
		Dog dog = new Dog();
		dog.eat();
		
		new Cat().eat();
	}
}

class Dog extends Animal {
	
//	重写父类的方法
//	明确种类的
	public void eat() {
		System.out.println("狗狗在吃....");
	}
//	若同名不同参,是方法的重载
	public void eat(int a) {
		
	}
}

class Cat extends Animal {
//	添加该注解,表示父类的方法必须重写
	@Override
	public void eat() {
		System.out.println("猫在吃鱼");
	}
}

9.2.9super关键字(记忆)

类似于this
含义:调用父类的对象,就是父类的意思
作用:调用父类的属性,方法,构造方法

package com.qf.test04;

public class Animal {
//	父类中定义属性
	public int a = 10;

	public void show() {
		System.out.println("展示...");
	}
	
	public static void main(String[] args) {
//		new Dog().show();
		
		new Dog().a();
		new Dog().b();
	}
}

class Dog extends Animal {
	public int a = 20;

//	写父类中方法的名+alt+/
	@Override
	public void show() {
//		调用父类的
//		super.show();
		
		System.out.println("狗狗展示");
	}
//	this/super可以用于区分父类中子类中重写的方法(只有严格区分时才使用)
	public void a() {
//		调用父类的
		super.show();
//		继承来的
		show();
//		继承来的
		this.show();
	}
	
	public void b() {
//		继承来的省略了this
		System.out.println(a);
		System.out.println(this.a);
//		父类中的
		System.out.println(super.a);
	}
}

9.2.10子类创建对象的过程

对象创建的过程
 1.开辟空间
 2.初始化属性
 3.执行构造
 4.创建对象的引用
继承后对象的创建过程
 先创建父类的对象,初始化父类的属性,执行父类的构造
 再创建子类的对象,初始化子类的属性,执行子类的构造

父类的构造无法被继承,但是子类创建对象是必须先调用父类的构造方法

package com.qf.test04;

public class Person {

	String name;
	
	public Person(String name) {
		this.name = name;
	}
	
	public Person() {
		System.out.println(name);
		System.out.println("我是父类的构造");
	}
	
	public static void main(String[] args) {
		new Student();
	}
}

class Student extends Person{
	
	int age;
	
	public Student() {
//		子类的构造方法的第一行默认是调用父类的无参构造方法
//		super();//不写默认调用
//		调用父类带参构造
//		super("");
		System.out.println(age);
		System.out.println("我是子类的构造");
	}
}