java基础-面向对象四大特征（封装，继承，多态，抽象）

java四大特征是：封装，继承，多态，抽象

 

一， 封装：数据和基于数据的操作封装在一起，使其构成一个独立实体，数据被保护内部，尽可能地隐藏内部的细节，只保留一些对外接口使之与外部发生联系。用户是无需知道对象内部的细节，但可以通过该对象对外的提供的接口来访问该对象。

1) 良好的封装能够减少耦合。

2) 类内部的结构可以自由修改。

3) 可以对成员进行更精确的控制。

4) 隐藏信息，实现细节。

封装访问控制修饰符：

 

1. public-----公共的，整个项目都可以调用
2. default----默认的，同一个包下可以调用
3. protect----受保护的，子类和同一个包下可以调用
4. private----私有的，只能类本身调用
5.  

二，继承：继承实现了 is-a 关系，是从已有类得到继承信息创建新类的过程，遵循里氏替换原则：当一个子类的实例应该能够替换任何其超类的实例时，它们之间才具有 is-a 关系。

package com.great.demo1;

public class Demo1 {

	/*
	 * 继承：得到父辈或祖辈的基业，财产，权力等
	 * java代码中的继承：类与类的继承   is..a
	 * 类与类之间的关系:继承
	 * 
	 * 父类(超类)：对于子类更加抽象的，被继承的类 --- super
	 * 子类：对于父类更加具体，继承父类的类
	 * 
	 * java中的表达方式（格式）（背）：
	 * 在子类的类名之后，加上： extends 父类类名
	 * 例子：
	 * 企鹅类继承于动物类
	 * public class Penguin extends Animal{}
	 * 
	 * 需要使用继承的条件：
	 * 1.需要有两个类
	 * 2.满足 is a 条件
	 * 
	 * 继承的特点：
	 * 1.子类如果拥有对应的属性，则可调用该属性，如果没有这个属性，查看父类是否拥有，如果有，则调用父类的属性
	 * 2.子类如果拥有对应的方法，则可调用该方法，如果没有这个方法，查看父类是否拥有，如果有，则调用父类的方法
	 * 3.单继承 --- 父类只允许有一个
	 * 4.this，super用法
	 * this：代表当前的类变量(类对象)
	 * 注意：this，只能在当前类中使用
	 * 作用：
	 * this可作为调用方法，属性使用 结构：this.属性名; 或者  this.方法名();
	 * this可调用构造方法中的逻辑代码 结构：this(对应的实参);
	 * 注意：this调用构造方法只能写在构造方法中
	 *      this调用构造方法只能写在构造方法逻辑代码最前面
	 *      只能调用该类的其他构造方法
	 *  
	 
	 * super：代表当前的父类变量(父类对象) 
	 * 注意：super，只能在子类中使用
	 * 作用：
	 * super可作为调用方法，属性使用 结构：super.属性名; 或者  super.方法名();
	 * super可调用构造方法中的逻辑代码 结构：super(对应的实参);
	 *     注意：super调用构造方法只能写在构造方法中
	 *      super调用构造方法只能写在构造方法逻辑代码最前面
	 *      只能调用父类的对应构造方法
	 * 4.1.
	 * 
	 * 
	 * 
	 * 
	 * 5.重写和重载用法
	 * 重载:在一个类中，方法名字相同，形参的个数，类型，顺序只要有一个不同即可造成两个方法的重载
	 * 注意：自定义方法和构造方法都可以重载
	 * 
	 * 6.父类拥有构造函数，子类也需要拥有对应的构造函数
	 * 
	 */
	public static void main(String[] args) {
		
		
		
		
		/*System.out.println(p.age);*/
		/*p.eat();*/
		Penguin p = new Penguin();
		System.out.println("main:"+p);
		p.sleep();
		
		
		Penguin p1 = new Penguin();
		System.out.println("main:"+p1);
		p1.sleep();
		
/*		Bear b = new Bear();
		b.eat();*/
		
		p.eat();
	}
}

 

package com.great.demo1;

public class Stu {

	private String name;
	private int age;
	public Stu(String name){
		this(20);
		
		//这里如果直接打印name的话，系统会就近原则，选择形参中的name进行打印
		//如果这时候需要调用的是全局变量name，就需要 this.name 来进行调用
		System.out.println(this.name);
		this.name = name;
		
		
	}
	
	public Stu(int a){
		age = a;
	}
	
}

demo3  super与this举例

package com.great.demo2;

public class Test {

	public static void main(String[] args) {
		Tiger t = new Tiger(20);
		Animal a = new Animal(10);
		System.out.println(t.age); 
	}
}
 

package com.great.demo2;

public class Animal {
	
	int age;
	
	public Animal(int age){
		this.age = age;
	}
	

}

package com.great.demo2;

public class Tiger extends Animal{

	public Tiger(int age) {
		super(age); //调用父类的构造方法，传递age参数
		
	}

}

 

三，多态：允许不同子类型的对象对同一消息做出不同的响应。

package com.great.demo1;

public class Penguin extends Animal{

	/*
	 * @Override:重写
	 * @Overload:重载
	 * 
	 * 
	 * 重写：
	 * 要求：
	 * 1.需要满足继承或者实现接口关系
	 * 2.父类和子类都需要有相同的方法名
	 * 3.在方法名前一行标记@Override都是属于重写(规定下面的方法是属于重写方法)
	 * 4.子父类拥有相同方法名的方法并且形参的个数，类型，顺序都需要相同,并且返回值类型也需要相同
	 * 5.子类和父类的修饰符：父类范围比较小，或和子类相同,但是不能使用private
	 * 6.重写仅仅应用在自定义方法中，重载多数用在构造方法中
	 * 
	 * 继承：
	 * 特点：
	 * 1.如果一个类没有书写继承其他类，系统会默认让该类继承于Object类 (所有的类都继承或间接继承Object这个类)
	 * 2.
	 * 
	 * 注意：调用重写方法快捷方式：Source --- Override/Implements methods点击即可
	 * 
	 * 
	 * 多态：
	 * 含义：子类或实现类，表现出父类或接口类的多种状态(父类对象通过子类进行初始化，可以调用子类重写方法或方法)
	 * 结构： 父类类名 变量名 = new 子类类名();
	 * Animal animal = new Fish();
	 * 
	 * 特点：
	 * 1.父类只能调用子类的重写方法
	 * 2.如果是调用属性，绝对是调用父类的属性
	 * 3.如果子类没有该重写方法，调用的是父类的方法
	 * 
	 */
	
	
	@Override
	public void eat(){
		System.out.println("Penguin eat fish...");
		super.eat();  //子类调用父类的eat（）方法用super.eat（）
		
	}
	
	
	
	
	
	public void sleep(){
		
	}
	
	
}

 

修饰符static 与 final

 

package com.great.demo3;

public class Animal {

	/*
	 * static:静态
	 * 
	 * 特点：
	 * 1.设置成静态的属性和方法可以直接调用，即：类名.变量名 或 类名.方法名()
	 * 2.一般我们不使用静态修饰符，静态修饰符如果要用和final进行搭配
	 * 3.在静态方法中只能得到静态的全局变量和静态的方法
	 * 4.在正常的方法中可以调用静态的全局变量和静态的方法
	 * 
	 * 
	 */
	
	public  static  int age = 10;
	public int a = 20;
	
	public static void eat(){
		System.out.println("animal eat...");
		System.out.println(age);
		//一下两句话解开会报错 因为在静态方法中只能得到静态的全局变量和静态的方法，要调用必须用new方法
//		System.out.println(a);
//		sleep();
	}
	
	public void sleep(){
		eat();
	}
}

package com.great.demo3;

/*
 * final:最终的
 * 如何将变量设置为常量
 * 
 * 加上final修饰的变量就会变成常量
 * 注意：
 * 1.常量是固定的不能改变的量
 * 2.常量的初始化是不能声明的，需要直接初始化
 * 3.final用来设置复合引用类型时，变量的地址无法改变，复合引用类型中的属性只要不设置终态可以被改变
 * 4.final用来设置基本数据类型时，变量的值无法改变
 * 
 */

public class Demo3 {
	
	 final public int A = 10;  //常量用大写，直接初始化
	 final Demo3 DEMO = new Demo3();
	 
	 int aa = 20;
	 public Demo3(){
		 DEMO.aa = 30;
	 }
	 
	/*final int B;*/ //解开这个注释就会报错
	
	public static void main(String[] args) {
		Demo3 demo3 = new Demo3();
		System.out.println(demo3.A);
		/*demo3.A = 20;*/ //这里是会报错的，原因是常量是固定的不能改变的量
		
		
	}
	
	
	

}

 

四，抽象：抽象是将一类对象的共同特征总结出来构造类的过程

 

package com.great.demo;

import java.util.Scanner;

/*
 * 接口类
 * 结构：public interface 接口类类名{}
 * 特点：1.接口类中的属性无法直接声明(必须初始化),默认是常量（final）,默认是静态的,默认是public类型
 *      2.方法没有逻辑代码 --- 抽象方法,默认不是静态，默认是public类型
 *      3.正常类和接口类之间是实现的关系
 *      4.正常类如果实现一个接口类，那么必须重写接口的方法
 *      5.接口是无法正常实例化的，需要重写内部的方法
 *      6.接口是可以实现多态的
 *      7.一个类可以实现多个接口，但是都需要重写接口内部的方法
 *      8.接口和接口是继承
 *      9.如果一个类实现了子类接口，那么需要重写子类接口的所有方法和其子类的父类接口的所有方法
 * 什么时候用：
 * 1.没办法继承
 * 2.不需要父类的方法中的逻辑代码
 * 3.必须重写父类的所有方法
 * 
 * 
 * 
 * 作用：主要作为实现类使用
 * 实现的结构：implements:实现的意思
 * 在一个正常类的类名后，加上 implements 接口类类名     
 * 
 * 
 * 抽象：将属性和方法抽取出来放置在一个抽象类中
 * 
 * 抽象类
 * 结构：public abstract class 抽象类类名 {}
 * 
 * 特点：1.和正常类一样使用
 *      2.居于接口类和正常类之间，里面可以书写抽象方法（方法可以没有逻辑代码）
 *      3.抽象方法书写：在修饰符中添加 abstract ---和接口中的抽象方法一样，只要继承该抽象类，必须重写抽象方法
 *      4.关系：抽象类 抽象类 继承
 *             类 类 继承
 *             接口类 接口类  继承
 *             类 接口类 实现
 *             抽象类 接口类  实现
 *             类  抽象类  继承
 * 
 * 
 * 
 */



public class Demo {

	public static void main(String[] args) {
		
		
		Scanner sc = new Scanner(System.in); //初始化屏幕对象
		System.out.println("请输入行：");
		int i = sc.nextInt(); //等待用户输入数字，将数字赋值给整形变量i
		System.out.println("===:"+i);
	}
	
	
}

package com.great.demo;
//接口类与接口类之间是继承关系
public interface Test extends Test1{

	int A = 10;
	
	 void getA();
}

 

package com.great.demo;

public interface Test1 {

	
	public void b();
}

package com.great.demo;

public abstract class Test2 {

	public void a(){
		
	}
	
	abstract public void b();
}

package com.great.demo2;

import com.great.demo.Test;
import com.great.demo.Test1;

//在这里Demo叫做实现类，也叫作正常类
public class Demo implements Test,Test1{

	public static void main(String[] args) {
		Demo d = new Demo();
		d.getA();
		Test t = new Demo(); //接口是可以实现多态的
		t.getA();
		
		//接口是无法正常实例化的，需要重写内部的方法
		Test t1 = new Test() {
			
			@Override
			public void getA() {
				// TODO Auto-generated method stub
				
			}

			@Override
			public void b() {
				// TODO Auto-generated method stub
				
			}
		};
	}

	@Override
	public void getA() {
		// TODO Auto-generated method stub
		System.out.println("aaa");
	}

	@Override
	public void b() {
		// TODO Auto-generated method stub
		
	}
}