Java中的继承,封装

this关键字

• this指代当前new的对象
• this使用在构造器中,调用本类中的其他构造器
  使用方法:
  this(参数列表) , 必须在构造器的首行使用

ublic class Computer01 {
	public String brand;
	public double price;
	public String color;
	
	public Computer01() {
		System.out.println("空构造");
	}
	
	public Computer01(String brand, double price) {
		//this("",1,"");
		this.brand = brand;
		this.price = price;
		System.out.println("带2个参数的构造);
	}

	public Computer01(String brand, double price, String color) {
		//就近原则
		this(brand,price);
		this.color = color;  //this指代当前创建的对象
		System.out.println("带3个参数的构造器");
	}
	
	public void test(){
		String brand="哈哈";
		//this指代当前调用成员方法的对象    com.brand
		System.out.println(this.brand+"-->"+this.price+"-->"+color);
	}
	
}

this关键字的作用:

1. this使用在成员方法中或者在构造器中,区分同名变量问题(局部和成员同名问题)
2. this指代当前对象或者当前调用方法的对象
3. 如果没有出现同名的成员和局部的问题,如果想要指代成员,必须使用this
4. 如果没有出现同名问题,只有成员变量,相当于省略的this

注意事项

• 不能使用this关键字进行构造器之间的相互调用
• this和static不能同时使用

static关键字的作用

• static修饰变量: 静态变量|类变量

• 只能修饰成员,不能修饰局部,static是成员修饰符

• static修饰方法: 静态方法|类方法

• static的使用方式: 1.类名.属性名|方法名(); 2.对象.属性名|方法名();

static的特性

• 静态的是属于类的,成员属于对象的

• 类的所有对象公用类中静态的内容

• 静态的内容是独一份的,在类第一次加载就初始化

• 在静态的内容中,可以直接使用静态的内容,不能直接使用非静态的内容,可以跟随对象使用

• 在非静态的内容中,可以直接使用静态的内容,也可以直接使用非静态的内容

  block 块 { }

• { } 定义在方法中–>局部代码块或者普通语句块 执行时机: 方法调用时

• { } 定义在类中方法外–>构造块 执行时机: 创建对象的时候

• static{ } 定义在类中方法外–>静态块 **执行时机:**类第一次加载时

• { }就是一个作用域

• 构造块中代码先于构造器代码执行,如果有多个构造块,从上到下依次执行

• static只执行一次,在类第一次加载后执行,如果存在多个静态块,从上到下依次执行

执行顺序: static->main方法–>构造块–>构造器

eclipse的Debug

• debug是什么? debug是一种eslipse的一种调试工具.
• **使用方式:**在eclipse上方的工具栏中有一个图形为虫子的按钮,点击进入debug模式, 然后带左侧的行数按钮上打断点,按f6下一步,一次执行,要想退出debug模式,那么点击右上角的java就可以了.

导包

• 导包需要关键字 import 标识当前所使用的这个类的位置

   		* 模糊匹配（会将该包下所有用到的类引入进来），
   		会降低编译速度，但是不会影响运行速度
  

import java.util.Scanner;//导包
import java.util.*;//模糊匹配（会将该包下所有用到的类引入进来），
				会降低编译速度，但是不会影响运行速度

不需要使用 import 的类有
1、 语言包 （java.lang）下的类
2、 同包下的类

JDK 中常用的包简单介绍：
①java.lang –语言包：语言中常用的功能，如 String、Math、
System、Integer、Thread… ②java.util – 工具包：提供一些实用的工具类，如 容器（List、
Set、Map…）,日期类
③java.io – 输入输出包：提供操作读取文件的相关类，如 File、
InputStream、OutputStrem… ④ java.net – 网络包 ： 操 作 远 程 资 源 的 类 ， 如
InetSocketAddress、 DatagramPacket 、ServerSocket… ⑤java.sql – 数据库包：操作 JDBC 的类，Connection、Statement、
ResultSet….

封装javaBean

public class Person01 {
	public String name;
	private//int age;  //只能在当前类Person01类中使用
	
	public Person01() {
		// TODO Auto-generated constructor stub
	}

	public Person01(String name, int age) {
		this.name = name;
		this.age = age;
	}
	
	//设置器  setter
	//返回值:不需要		参数:要 int 
	//成员方法
	public void setAge(int age){
		if(age>=0 && age<=150){
			this.age=age;
		}else{
			System.out.println("年零不合法...");
		}
		
	}
	
	//获取器
	public int getAge(){
		return this.age;
	}
}
public static void main(String[] args) {
		Person01 p = new Person01("小花,17);
		p.name="小明";
		//p.age=-5;
		p.setAge(18);年龄是私有的,需要调用公共的方法来实现
		System.out.println(p.getAge();
		
	
	}

• 封装（Encapsulation）是面向对象方法的重要原则，就是
  把对象的属性和行为（或方法）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。
  • 这里介绍一个关键字 private 私有的

关键字private的特性:

1.private 修饰的内容,只能在当前类或者本类中使用
2. 需要为私有的字段提供一对公共的访问方式 设置setter 获取器 getter
3. 私有的属性需要配合公共的访问方式–>方法

私有的属性并且提供公共的访问方式是面向对象中封装特性的体现,
私有是封装,不能说封装是私有,因为封装不仅仅表示为私有

封装
隐藏内部的实现细节,并对外提供公共的访问方式

封装的优点：

1. 隐藏实现细节，提供公共的访问方式
2. 提高代码的复用性
3. 提高代码的安全性

 模板类|javaBean|bean...规范

 1. 修饰类的public
 2. 至少提供一个空构造
 3. 属性私有化
 4. 对外提供公共的访问方式  

继承extends

• 继承的目的: 为了简化代码

• 继承的特点:

   	 	1.子类一旦继承父类,就可以使用父类的内容
   	 	2.单继承继承:一个子类只能继承一个父类,一个父类可以被多个子类继承,多实现
  

子类|派生类: 继承别的类
父类|基类|超类: 被继承的类

类就是对对象的抽象
父类就是子类的抽象

单继承的优缺点:

      优点:简单
      缺点:不便于后期维护

• 子类是父类的延续+ 扩展 extends
• 子类可以使用父类中的内容,可以定义子类独有的内容

public static void main(String[] args) {
		Teacher th=new Teacher();
		th.subject="数学";
		th.teach();
		th.name="吕进;
		th.age=17;
		
		Student s=new Student();
		s.hometown="日本;
		s.study();
		s.name="小兰";
		s.age=50;
		s.sleep();
		
	}
}

//父类
class Person{
	String name;
	int age;
	
	public void sleep(){
		System.out.println("休息");
	}
}

//子类  教师类
class Teacher extends Person{
	
	String subject;
	
	public Teacher() {
		// TODO Auto-generated constructor stub
	}
	
	public void teach(){
		System.out.println("每天上课都讲数学");
	}
	
	
}

//学生类
class Student extends Person{
	String hometown;
	
	public Student() {
		// TODO Auto-generated constructor stub
	}
	public void study(){
		System.out.println("学习数学,做数学题,学习使我快乐");
	}
/*

使用继承的格式:
			 子类 extends 父类
		上面的代码中,子类是 Student 和Teacher 只需要在子类的类名后加上extends 父类的类名即可完成类的继承
*/

**权限修饰符:**  定义对象中内容的可访问范围					
 				
				
        
                    本类       同包类    不同包子类       不同包其他类
    public 			Y			Y			  Y               Y
	protected       Y			Y			 Y
	default(默认)	Y			Y
	private			Y



 
 
  以上权限修饰符: 都只能修饰成员,不能修饰局部
  能够修饰类的只有default|public 
  
   **protected:**
		1.同包类,本类中直接使用
			2.不同同包下的子类,必须通过继承关系才能使