java面向对象三大特性

封装

• 改露的露，该藏的藏
  • 我们程序设计要追求高内聚，低耦合,高内聚就是类的内部数据操作细节自己完成，不允许外部干涉，低耦合，仅暴露少量的方法给外部使用
• 封装
  • 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
• 记住这句话就够了：属性私有，get/set

代码理解

//Student 类
public class Student {
	//属性私有
	private String name;//姓名
	private int id;//学号
	private char sex;//性别
	private int age;//年龄
	
	//提供一些可以操作这个属性的方法！
	//提供一些public的get、set方法
	
	//get 获得这个数据
	public String getName() {
		return this.name;
	}
	//set给这个数据设置值
	public void setName(String name) {
		this.name=name;
	}
	//idea中  alt+insert 快捷键生成   eclipse 右键->source
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public char getSex() {
		return sex;
	}
	public void setSex(char sex) {
		this.sex = sex;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		if(age>120||age<0) {
			age=3;
		}
		this.age = age;
	}
	
}

//测试类
public class test {
	public static void main(String[] args) {
		Student s = new Student();
		s.setName("张三");
		System.out.println(s.getName());//张三
		s.setAge(200);
		System.out.println(s.getAge());//3
	}
}

扩展

为什么println什么都能输出？

原因：println实现了许多方法重载，点进源码可知

继承

• 重要关键字 extends
• java类中只有单继承，没有多继承
• object是所有类的父类（所有的类都直接或间接继承Object类）

代码理解

//父类
public class Father {
	public void yichang() {
		System.out.println("留下了一亿遗产");
	}
}

//子类
public class Son extends Father{
	
}

//测试类
public class Test {
	public static void main(String[] args) {
		Son s=new Son();
		s.yichang();
	}
}

//打印结果	留下了一亿遗产
//意思就是Son都没有yichan这个方法，但是可以调用父亲的，原因就是继承了父类

super关键字

//父类
public class Father {
	protected String name="父亲";
	
	
	public Father() {
		System.out.println("Father无参构造");
	}
	
	//私有的东西无法被继承
	public void print() {
		System.out.println("父亲1");
	}
}


//子类
//继承了Father类，会拥有它的所有方法
public class Son extends Father{
	private String name="儿子";
	
	public void print() {
		System.out.println("儿子1");
	}
	
	public Son() {
		//隐藏代码：调用了父类的无参构造
		super();//要在第一行！！！！否则报错
		System.out.println("Son无参构造");
	}
	
	
	public void test1() {
		print();//儿子1
		this.print();//儿子1
		super.print();//父亲1
	}
	
	public void test(String name) {
		System.out.println(name);//erzi
		System.out.println(this.name);//儿子
		System.out.println(super.name);//父亲
	}
}

//测试类
public class test {
	public static void main(String[] args) {
		Son s=new Son();
		//Father无参构造
		//Son无参构造
		s.test("erzi");
		s.test1();
		
	}
}

• super注意点

  • 1.super调用父亲的构造方法，必须在构造方法的第一个
  • super必须只能出现在子类的方法或者构造方法中
  • super和this不能同时调用构造方法

  VS this

  • 代表的对象不同
    • this：本身调用者这个对象
    • super：代表父类对象的应用
  • 前提
    • this：没有继承也可以使用
    • super：只能在继承条件下才可以使用
  • 构造方法
    • this( );本类的构造
    • super( );父类的构造

  ​

方法重写

• 关键字@Override（而且只能public，private不能重写）
• 前提：需要有继承关系，只重写父类的方法
• 修饰符：方位可以扩大不能缩小： Public>Protected>Default>private
• 子类的方法和父类必须要一致，方法体不同

多态

• 多态是方法的多态，属性没有多态
• 存在条件：继承关系，方法需要重写
  • static 方法，属于类，它不属于实例
  • final 常量（无法重写）
  • private 私有不能被继承

代码理解

//父类 Father
public class Father {
	//私有的东西无法被继承
	public void run() {
		System.out.println("father->run");
	}
}

//子类 Son
//继承了Father类，会拥有它的所有方法
public class Son extends Father{

	@Override
	public void run() {
		System.out.println("son->run");
	}
	
	public void eat() {
		System.out.println("son->eat");
	}
}

//测试类
public class test {
	public static void main(String[] args) {
        //这就是多态
		//能调用的方法都是自己的或者继承父类的
		Son s1=new Son();
		//父类型，可以指向子类，但是不能调用子类独有的方法
		Father s2=new Son();
		Object s3=new Son();
		
		s1.eat();//son->eat
		//s2.eat();调用不了
		s2.run();//son->run  子类重写了父类的方法，执行子类的方法
		s1.run();//son->run	
	}
}