this关键字、static关键字、block块、封装类以及继承、import、修饰符的初步了解

this关键字

定义

在类的方法定义中使用this关键字代表使用该方法的引用.

this即"自己",代表对象本身,谁调用代表谁.在成员方法中或构造器中隐式的传递.

this的两种用法

1. 构造器中

   1. 作用:可以调用本类中的其他构造器

   2. 具体用法可参照2.2的中的代码

2. 成员变量与局部变量

   1. 作用:当成员变量与局部变量同名时,可以采用this关键字代指当前对象的属性(即成员变量)

   2. 具体用法:

      public class Computer01 {
       public String brand;
       public double price;
       public String color;
          //this的用法:代指当前对象的属性值 
       public Computer01(String brand,double price){
        this.brand=brand;//this.brand是当前对象的属性名,brand是传入值(局部变量)
        this.price=price;
        System.out.println("带参构造器1");
       }
       public Computer01(String brand,double price,String color){
        this(brand,price);    //this的用法:调用构造器1
        this.color=color;
        System.out.println("带参构造器2");
       }  
      }

注意事项

1. this在构造器中只能放在首行

2. 利用this关键字可以避免属性和形参 局部变量同名,发生就近原则.

   1. 就近原则:在此例中就是当局部变量与成员变量中就会先找局部变量.

3. this([实参列表]):可以调用其他构造器

4. this可以看做是一个变量,它的值是当前对象的引用

5. this不能出现在被static修饰的内容中

   1. 因为this代表对象的引用,而static是在类加载的时候而此时对象还未创建.

6. 构造方法不能相互调用,此时会造成类似死循环的效果,会报错.

7. 当只有成员变量时,默认省略了this关键字.

static关键字

含义

在类中，用 static 声明的成员变量为静态成员变量，它为该类的公用变量，在第一次使用时被初始化，对于该类的所有对象来说，static 成员变量只有一份。凡是静态的都是属于类的，与对象无关的，先于对象存在的。可用于修饰属性、方法、块。

解释:

1. static声明的修饰的成员变量、成员方法、块都是静态成员变量、成员方法、块。

2. 静态在第一次使用的时候(即类加载时)就被初始化,先于对象存在。

调用方式(两种)

1. 类名.静态属性|方法名();

2. 对象.静态属性|方法名();

注意:

1. 静态方法只能使用静态内容;即被static修饰的方法只能使用被static修饰的内容

2. 类的所有对象都共用静态的内容

3. 静态内容在类的第一次加载时就被初始化

4. 非静态内容可以使用非静态内容也可以使用静态内容

public class StaticDemo01 {
 static int id=5;//静态
 int age=10;//成员变量
  public static void main(String[] args) {
  //类中,静态变量与成员变量的使用区别 
   System.out.println(StaticDemo01.id);//可以省略类名 5
   System.out.println(id);//与上行一致 5
//   System.out.println(age);//不能直接使用成员变量,必须跟随对象使用
   StaticDemo01 staticDemo01=new StaticDemo01();
   System.out.println(staticDemo01.age);//这个就可以使用了 10
  
  //也可以采用对象.类变量 获取类变量 的值
   System.out.println(staticDemo01.id);//5
   //此行时,id=5,age=10;
   staticDemo01.change();
   
   System.out.println(id);//7
   System.out.println(staticDemo01.age);//15  
   //局部变量的使用
   String name="";
   System.out.println(name);    
  }
  //创建一个方法
  public void change(){
   id++;//6
   age+=5;//11
   StaticDemo01 staticDemo01=new StaticDemo01();
   id++;//7
   staticDemo01.age+=2;//11
   System.out.println(id+"---"+staticDemo01.age);//7 12
   System.out.println(id+"---"+this.age);//7 11
  } 
}

block块

分类

1. {}定义在方法中 ->局部代码块|普通语句块 执行时间:方法调用时

2. {}定义在类中方法外 ->构造块 执行时间:创建对象的时候

3. static{}定义在类中方法外 ->静态 执行时间:类第一次加载的时候

其执行顺序如下 static -> main主方法 ->构造块 ->构造块

示例

public class BlockDemo01 {
 static int a=45;
 int b=30;
 public static void main(String[] args) {
  System.out.println("主方法");
  BlockDemo01 b12=new BlockDemo01();
 }
 //类中方法外
 {
  System.out.println("构造块2");
  System.out.println(a);
  /*
  * 创建对象分为三步(在堆中)
  *  一是开辟空间,携带属性进入(如果没有值,则携带默认值,有值就是值本省)
  *  在第一步的时候,已经携带属性b=3进入内存中,执行构造块
  *  二是采用构造器初始化变量(第一次赋值)
  *  三是返回内存中的位置 
  */
  System.out.println(b);
 }
 {
  System.out.println("构造块3");
 }
 {
  System.out.println("构造块4");
 }
 static{
  System.out.println("静态块1");
  System.err.println(a);
  //由于静态是在对象创建之前,所以无法使用b
//  System.out.println(b);
  BlockDemo01 b12=new BlockDemo01();
  System.out.println(b12.b);
 }
 static{
  System.out.println("静态2");
 }
 static{
  System.out.println("静态3");
 }
}

封装javaBean

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

优点：

A:隐藏实现细节，提供公共的访问方式

B:提高代码的复用性

C:提高代码的安全性

注意：私有是封装，不能说封装是私有,封装不仅仅表示为私有。私有只是封装的一种体现，方法是封装的一种体现。

javaBean编码规则：

1. javaBean 必须声明为 public class，这样才能够被外部所访问；

2. 一个 JavaBean中至少存在一个无参构造方法

3. 类中所有的属性都必须封装，即：使用 private 声明；

4. 为封装的私有属性提供公共的 setter、getter 方法

Garbage Collection 垃圾回收机制

1. 程序员无权调用垃圾回收器。

2. 程序员可以通过 System.gc()。通知 GC 运行，但是 JAVA规范并不能保证立刻运行。

3. finalize 方法，是 JAVA 提供给程序员用来释放对象或资源的方法，但是尽量少用

示例：

public class GCDemo01 {
 public static void main(String[] args) {
  //匿名对象 :没有名字的对象
  //只能在当前行使用一次
  GCDemo01 g=new GCDemo01();
  System.gc(); //通知
  System.out.println("123");
  System.out.println("123");
  System.out.println("123");
  System.out.println("123");
  
 }
 
 public void haha(){
  System.out.println("哈哈哈哈,最近还是先吃火锅~~~");
 }
 
 @Override
 protected void finalize() throws Throwable {
  System.out.println("over....");
 }
}

package和import语句

package语句

为了便于管理大型软件系统中数目众多的类，解决类的命名冲突问题，Java 引入包(package)机制，提供类的多重类命名空间。

一般的命名为:公司域名倒写+功能名|模块名。例如：package com.shsxt.import06;

package 语句作为 Java 源文件的第一条语句，指明该文件中定义的类所在的包。（若缺省该语句，则指定为无名包）。

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

如果一个类存在包名，则在使用该类时，必须使用全额限定名（简称全名或完整类名，com.shsxt.MyClass），编译器才能找到该类；也可以使用 import 在文件的开头引入要使用到的类。

import

1. 类的上面进行导包:

2. import 关键字 标识当前所使用的这个类的位置

3. 这个包下的所有的类,如果有使用都可以引用

4. 会降低编译效率,不会降低运行效率

5. 静态导入: 只导入静态的内容

6. 如果不使用import可以在使用的位置指明类的位置,包名+类名

注意:不要与jdk的 包名,类名出现相同情况

示例

import static java.lang.Math.PI;
import static java.lang.Math.sqrt;
import java.util.*;
public class ImportDemo06 {
 public static void main(String[] args) {
  Scanner sc=new Scanner(System.in);
  Random ran=new Random();
  
  System.out.println(PI);
  System.out.println(PI);
  System.out.println(PI);
  System.out.println(PI);
  
  System.out.println(sqrt(4));
 }
}

extends继承

继承：子承父业

java 中使用 extends 关键字实现类的继承机制，语法规则：

<modifier> class <name> [extends <superclass>]{}

[ ]代表可有可有

作用

实现代码的复用，延续+扩展父类信息，子类可以扩展自己的内容 通过继承，子类自动拥有了基类的所有成员（成员变量和成员方法）。 Java 只支持单继承，不允许多继承：一个子类只能拥有一个基类，一个基类可以派生出多个子类

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

示例

public class ExtendsDemo01 {
 public static void main(String[] args) {
  Teacher th=new Teacher();
  th.subject="java";
  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("每天上课,边讲课边说rap");
 }
 
 
}
​
//学生类
class Student extends Person{
 String hometown;
 
 public Student() {
  // TODO Auto-generated constructor stub
 }
 public void study(){
  System.out.println("学习敲代码,敲代码使我快乐~~~");
 }
 
}

修饰符

权限修饰符: 定义对象中内容的可访问范围

	本类	同包	不同包子类	不同包其他类
public	Y	Y	Y	Y
protected	Y	Y	Y
default（默认）	Y	Y
private	Y

以上权限修饰符: 都只能修饰成员,不能修饰局部 能够修饰类的只有default|public

protected: 1.同包类,本类中直接使用 2.不同同包下的子类,必须通过继承关系才能使用

同类下

public class Modifier01 {
 //分别定义不同的修饰符的变量
 public String name="小王";
 protected String mood="unhappy";
 int age=520;
 private double money=150;
 //分别定义不同修饰符的方法
 public void method01(){
  System.out.println("public方法");
 }
 protected void method02(){
  System.out.println("protected方法");
 }
 void method03(){
  System.out.println("默认default");
 }
 private void method04(){
  System.out.println("private方法");
 }
 
 public static void main(String[] args) {
 //在本类中,四种修饰符都可以使用 
  Modifier01 m=new Modifier01();
  m.name="小王2";
  m.mood="开心2";
  m.age=521;
  m.money=1563;
  m.method01();
  m.method02();
  m.method03();
  m.method04(); 
 }
}

同包下其他类

package com.shsxt.modifier01;
public class Modifier02 {
 public static void main(String[] args) {
 //在本类中,四种修饰符都可以使用 
  Modifier01 m=new Modifier01();
  m.name="小王2";
  m.mood="开心2";
  m.age=521;
//  m.money=1563;
  m.method01();
  m.method02();
  m.method03();
//  m.method04(); 
 }
}

不同包的子类

package TestModifier;
import com.shsxt.modifier01.Modifier01;
public class Modifier03 extends Modifier01 {
 public static void main(String[] args) {
 //在不同包子类中,四种修饰符可以使用的方法 
  Modifier01 m=new Modifier01();
  m.name="小王2";
  Modifier03 m1=new Modifier03();
  System.out.println(m1.mood);
//  m.mood="开心2";
//  m.age=521;
//  m.money=1563;
  m.method01();
  m1.method02();
//  m.method03();
//  m.method04(); 
 }
}
​

不同包的其他类

package TestModifier;
import com.shsxt.modifier01.Modifier01;
public class Modifier04 {
 public static void main(String[] args) {
 //在本类中,四种修饰符都可以使用 
  Modifier01 m=new Modifier01();
  m.name="小王2";
//  m.mood="开心2";
//  m.age=521;
//  m.money=1563;
  m.method01();
//  m.method02();
//  m.method03();
//  m.method04(); 
 }
}