JavaSE.20190429.构造器.This.Static.block块.使用debug调试.gc.package.import语句.private.面向对象的三大特性之封装&继承.

一.构造器

     1.new创建对象做的三件事情:
        1)在堆中为对象开辟空间,成员属性会跟随对象进入到堆内存并赋默认值
        2)调用构造器为对象初始化信息
        3)将地址返回值引用
     2.构造器|构造方法|构造函数:
          *构造器是一个特殊的方法,只能和new一起使用*
        1)作用:
           初始化对象信息,不是用来创建对象的
        2)定义:
           构造方法的名字必须与当前的类名一致 ,不需要返回值不需要void
               修饰符 类名([参数列表]){
                   ...
                }
    
        3)如果没有自定义构造器,编译器会自动为你添加空构造(不带参数的构造器)
        4)如果存在自定义构造器,编译器这时不会再提供任何构造器,包括空构造
        5)构造器是方法,方法就可以构成方法的重载
        6)调用不同的构造器,看创建对象时候()中的参数列表匹配哪一个构造器的参数列表
        7)修饰符可以是private,私有的,只能在本类中使用(单例)
        8)构造器不能使用final,static,abstract修饰
    总结:特殊的方法,只能通过new的使用使用,可以重载没有返回值和void,区分重载构造器看new后()的参数

public class ConstructorDemo {
	//无参构造
	public ConstructorDemo(){
		System.out.println("我是一个无参构造器");
	}
	public static void main(String[] args) {
		ConstructorDemo con=new ConstructorDemo();
		//创建Dog对象
		Dog dog=new Dog(); //创建对象时候的()-->构造器的形参
		dog.name="uzi";
		dog.color="白色";
		dog.type="萨摩耶";
		dog.lookHome();
		//在创建对象的同时就可以指定或者初步确定这个对象的属性值,可以使用带参构造,在new对象的同时为对象的属性初始化值
		Dog dog2=new Dog("花卷","二哈","黄色");
		//dog2.color="粉色";
		dog2.lookHome();
	}
}
//小狗类
class Dog{
	//名字
	String name;
	//品种
	String type;
	//颜色
	String color;

	//编译器会自动为你添加一个这个样子的空构造,没有参数,没有内容
	public Dog(){
		System.out.println("我是空构造");
	}
	//带参构造  构造器可以重载
	public Dog(String n,String t,String c){
		System.out.println("我是带3参构造");
		name=n;
		type=t;
		color=c;
	}
	public Dog(String n,String t){
		System.out.println("我是带2参构造");
		name=n;
		type=t;
	}
	public void lookHome(){
		System.out.println("一个叫做"+name+"的"+color+"的狗在看家");
	}
}

二.this.

     1.指代当前new的对象,存储的就是当前对象的地址
        1)在构造器的首行通过this调用当前其他构造器
               this();  -->() 匹配构造器的参数
        2)区分同名成员变量和局部变量
           如果不使用this,会发生就近原则 
           在构造器中,this指代当前new的对象
           在方法中,this指代当前调用成员方法的这个对象
           如果不存在同名变量的问题,默认省略this.
           如果存在同名变量的问题,默认就近原则,区分成员,this.,this.不能省略
     2.注意:
       1)在构造器的首行调用其他构造器时候不能相互调用
       2)如果不使用,会发生就近原则 
       3)this不能使用在static修饰的方法中

     3.构造块在编译的时候会被放在构造器语句块中代码的最上面,如果存在this调用其他构造器,必然先调用其他构造器,因为this必          须存在于首行才能调用其他构造器

public class ThisDemo {
	public static void main(String[] args) {
		Computer com=new Computer("apple",-15000,"银色");
		System.out.println(com.brand);
		System.out.println(com.price);
		System.out.println(com.color);
		com.price=-10000;
		com.test("哈哈");
	}
}
//电脑类
class Computer{
	//品牌
	String brand;
	//价钱
	double price; 
	//颜色
	String color;
	//空构造
	public Computer() {
		System.out.println("我是空构造器");
	}
	public Computer(String brand,double price) {
		//this("",1.0,"");
		System.out.println("我是带二个参数造器");
		this.brand=brand;
		if(price>=0){
			this.price=price;
		}else{
			System.out.println("价钱<=0");
			return;
		}
	}
	public Computer(String brand,double price,String color) {
		this(brand,price);  //调用本类中的其他构造器
		this.color=color;
		System.out.println("我是带三个参数造器");
	}
	public void test(String brand){
		String color="绿色";
		System.out.println(this.brand+"->"+this.price+"->"+this.color);
	}
}

三.static

     1.static 关键字  静态的
        static修饰变量|静态变量|类变量,只能修饰成员变量,不能修饰局部变量
        static修饰方法|静态方法|类方法
        static修饰的内容的使用方式:
                          1)类名.
                          2)对象.
     2.注意:
        静态的内容是属于类的,成员的内容是属于对象的
        静态的内容是独一份的,这个类的所有对象共享这个类中的静态内容
        在静态的内容中只能直接使用静态的内容,不能直接使用成员的内容===>对象使用
        非静态的内容中,可以直接使用成员的内容,可以直接使用静态的内容

public class StaticDemo {
	static int age;
	int id;
	public static void main(String[] args) {
		//static int a=5;
		System.out.println(age);
		System.out.println(StaticDemo.age); //类名.
		StaticDemo staticDemo=new StaticDemo();
		System.out.println(staticDemo.age); //对象.
		change();
		System.out.println(age); 			// 1
		System.out.println(staticDemo.id);	// 0
		
		//哪个调用的成员方法,在这个成员方法中,成员|this指代的都是调用成员方法的对象
		staticDemo.test();
	}
	//静态方法  change
	public static void change(){
		age++;
		StaticDemo staticDemo=new StaticDemo();
		staticDemo.id++;
		System.out.println(staticDemo.id);
	}
	public void test(){
		age++;
		id++;  //哪个对象的成员
	}
}

四.块block

     1. {}自成作用域

         {} ---->方法中,局部代码块|普通语句块            执行时机:调用方法
         {} ---->类中方法外,构造块                               执行时机:创建对象
         static{} ---->静态块
    2.构造块先于构造器执行,如果有多个构造块,从上到下一次执行
    3.静态{}在第一次加载类的时候只执行一次,先于主方法执行,如果有多个静态块,从上到下一次执行
    4.执行的顺序:     静态块 --- main ---构造块---构造器

public class BlockDemo {
	static int a=5;
	int b=3;
	public BlockDemo() {
		System.out.println("我是空构造");
	}
	//构造块
	{
		System.out.println("我是构造块1"+this.b);
		a++;
		b++;
	}
	{
		System.out.println("我是构造块2");
	}
	{
		System.out.println("我是构造块3");
	}
	//静态块
	static{
		a++;
		BlockDemo bd=new BlockDemo();
		bd.b++;
		System.out.println("我是静态块");
	}
	static{
		System.out.println("我是静态块2");
	}
	static{
		System.out.println("我是静态块3");
	}
	public static void main(String[] args) {
		System.out.println("main");
		int a=9;  //局部变量在外部无法使用,只能在当前方法中使用
		{
			a=7;
		}
		System.out.println(a);    //
		BlockDemo bd=new BlockDemo();
	}
}

五.使用debug调试

    1.步骤:
       1)先打断点;(双击序号左边的蓝色区域)
       2) debug模式运行(点击小虫子)   

           快捷键:  f5 进入细节;    f6下一步执行 ;    f7返回方法的调用出;

六.gc

     1. System.gc() 通知系统回收,但是无权决定是否回收,什么时候回收 
     2. finalize() 在垃圾回收机制来回收垃圾第一步会调用的方法 
     3.  一定会调用finalize()方法的两种情况:
                            1)匿名对象;
                            2)对象无引用状态;

public class GCDemo {
	public static void main(String[] args) {
		//匿名对象  只能在当前行用一次
		new GCDemo().test();  //没有名字的对象
		//System.gc();
		//对象无引用状态
		GCDemo d=new GCDemo();
		d.test();
		GCDemo d1=d;
		d=null;
		System.gc();
	}
	@Override
	protected void finalize() throws Throwable {
		System.out.println("over...");
	}
	public void test(){
		System.out.println("hhhhhhhhhh");
	}
}

七.package 和 import

     1.注意: 不要定义与 jdk 相同的包，相同的类，否则会引起很多你觉得莫名其妙的问题;

     2.导包: 模糊匹配 *

     3.会拖慢编译效率,不会拖慢运行速度

     4.静态导入:单独导入类中的静态的内容

        可以导入变量可以导入方式

八.private

     1.私有的,成员修饰符,不能修饰局部变量

     2.私有的内容只能在当前类中使用

     3.如何使用私有的属性:
        对使用的属性提供公共的访问方式  setter设置器  getter访问器

九.面向对象的三大特征之一: 封装

     1.封装:对外隐藏内部的实现细节,提供公共的访问方式就是封装
                属性私有,公共的访问方式是封装的一个具体的体现(不能说封装是私有)
                类,方法都是封装的体现
      2.以后写模板类,属性都要私有,提供公共的访问方式
      3.这种模板类|实体类|javabean
         1)类是公共的public修饰
         2)至少存在一个空构造
         3)属性私有
         4)公共的访问方式
   

public class Person {
	//姓名
	String name;
	//年龄
	private int age;
	//设置器  setter  给私有的age属性的设置值
	//返回值:不需要			参数:int参数
	public void setAge(int age){
		if(age>0){
			this.age=age;
		}else{
			//如果参数不满足条件,默认1岁
			this.age=1;
		}
	}
	//学习
	public void study(){
		System.out.println(name+age+"早睡早起...");
	}
}

九.面向对象的三大特征之一: 继承

    1.抽取对象的共性定义为类;
       抽取类的共性定义为父类;
    2.为什么使用继承:
       为了提高代码的复用性
       如何使用继承(子承父业:拓展+延续):
       格式:   子类  extends 父类   ====>子类继承父类  ,例如 class Cat extends Animal{ }
    3.使用继承的优点:
      1)提高代码的复用性
      2)自动可以使用父类中的所有成员(属性和方法)
      3)子类可以定义属于自己的属性和功能  ---->扩展
   4.特点:
      父类可以有多个子类,但是一个子类只能有一个父类 ---->单继承
   5.单继承的优点: 使用简单
      单继承的缺点: 不便于后期维护
   6. 其它叫法:   父类|基类|超类
                         子类|派生类

public class ExtendsDemo {
	public static void main(String[] args) {
		Dog dog=new Dog();
		dog.name="小坤蔡";
		dog.type="柴犬";
		dog.color="土黄色";
		dog.shout();
	}
}
//父类
class Animal{
	String name;
	String type;
	String color;
	public void shout(){
		System.out.println(name+"叫叫叫!!!!");
	}
}
//小狗
class Dog extends Animal{
	public void lookDoor(){
		System.out.println(name+"看家!!!!");
	}
}
//小猫
class Cat extends Animal{
	//新增方法
	public void catchMouse(){
		System.out.println(name+"捉老鼠!!!!");
	}
}