static关键字

static：关键字静态的

被static关键字修饰的内容为静态内容

成员是属于对象的跟随对象使用，应为成员在对象的堆内存空间中，static修饰的静态的内容是属于类，可以随类使用。

静态变量都是独一份的，不存在对象的堆内存中，在静态区中在类第一次加载完成之后就会初始化静态内容。

成员的需要创建对象才在对象堆中存在成员，没有对象就没有成员。

在静态的内容中可以直接使用静态内容，但是不能直接使用成员内容，需要跟随对象使用成员，在成员内容中可以直接使用静态也可以直接使用成员

public class StaticDemo01 {//成员位置 : 类中方法外部//成员变量int a = 10;//静态变量static String str = "哈哈";public static void main(String[] args) {//局部//static int i = 1; static不能修饰局部,只能修饰成员//测试静态内容的使用方式System.out.println(str);//当前类中类名可以省略System.out.println(StaticDemo01.str);StaticDemo01 sd = new StaticDemo01(); //当前类型对象System.out.println(sd.a);System.out.println(sd.str);System.out.println(Math.random());System.out.println(Math.PI);}/*成员方法 : 需要被对象调用,在成员方法中的成员变量,默认指代当前调用成员方法的对象的成员*/public void test(){System.out.println(this.str);System.out.println(this.a);}
}

block：块

{ } ——>自成作用域。

{ }：方法中|语句块中——>局部代码块|普通语句块

执行时机：跟随方法调用。

{ }：类中方法外部——>构造块

执行时机：创建对象new的对象。

static{ }：类中方法外——>静态块

执行时机：类第一次加载完毕之后初始化。

注意：构造代码先于构造器之前运行，当存在多个构造块，从上到下依次执行，多个静态块从上到下依次执行，静态块在类第一次加载完成之后执行，并且只执行一次。

顺序：静态块——>main——>构造块——>构造器

public class BlockTest02 {public static int  a = 0;{a = 10;System.out.println(" 3、非静态代码块执行a=" + a); //}    static {a = 6;System.out.println("1、静态代码块执行a=" + a); //}public BlockTest02() {this(a); //System.out.println("6、"+a);  //System.out.println("7、无参构造方法执行a=" + a); //}public BlockTest02(int n) {System.out.println("4、"+n); //System.out.println("5、"+a);//}public static void main(String[] args) {System.out.println("2、main"); //BlockTest02 tsc = new BlockTest02();//6 10 10 6 10 10}
}

包机制

包机制：为管理众多java文件

导包：指明使用java类位置

不需要导包的类：

同包下的类

java.lang包下的内容不需要导包

导包的方式：

使用类型的时候指定类型的权限定名.包名.类名只在当前这一次有效。

使用import 包名.类名导包。定义在类上面，导入一次当前类中都可以使用。

模糊匹配 *：降低编译效率

静态导入 import static 包名.类名.静态内容。

package package03;
//模糊匹配
import java.util.*;//导入静态内容
import static java.lang.Math.PI;
//导入静态方法不要添加(),因为方法名()这叫方法的调用,执行方法中的代码
import static java.lang.Math.random;
public class ImportDemo01 {public static void main(String[] args) {//包名.类名: 权限定名java.util.Scanner sc = new java.util.Scanner(System.in);Scanner sc2 = new Scanner(System.in);List ls = new ArrayList();//静态变量System.out.println(PI);System.out.println(PI);System.out.println(PI);System.out.println(PI);System.out.println(PI);//静态方法System.out.println(random());System.out.println(random());System.out.println(random());System.out.println(random());System.out.println(random());}
}

private：私有的

数据不安全的情况下如：数据为负数，符合类型要求，但是不符合逻辑要求。

为了解决安全问题使用关键字private私有的：

只能在当前类使用，外部类中无法使用

私有的属性配合一套公共的访问方式一起使用：

设置器：为私有的属性进行赋值 setter

获取器|访问器：获取私有属性的值 getter

private是封装，封装不仅仅是private。

/*javabean: 泛指一系列的类模板类标准的javabean规范:1)类是公共的2)至少存在一个空构造3)属性私有化4)公共的访问方式 setter getter...*/
public class JavaBean05 {public static void main(String[] args) {Person p = new Person();//p.name = "久伴";//p.age = -18;p.setName("张三");p.setAge(19);System.out.println(p.getAge());p.code();}
}class Person{//姓名private String name;//年龄private int age;//构造器public Person(){}//设置器public void setAge(int age){if(age<=0 || age>=150){System.out.println("年龄不合法!!!");return;}this.age = age;}public void setName(String name){this.name = name;}//访问器public int getAge(){return age;}public String getName(){return this.name;}public Person(String name,int age){this.name = name;this.age = age;}//码农public void code(){System.out.println(age+"的"+name+"正在敲代码!!!!!");}}

继承

继承：子成父类

继承的目的：为了提高代码的复用性。

子类|派生类：继承父类的类。

父类|基类|超类：被继承的类。

类：抽取对象的共性。

父类：抽取子类的共性定义在父类中

特点：

子类一单继承父类，就有权使用父类中的成员。

子类中定义子类独有的内容。

extends子类是父类的延续，扩展。

一个父类可以存在多个子类。

单继承机制：一个子类只能存在一个父类。

接口可以多实现。

单继承的优点：简单

单继承的缺点：不够灵活，不便于程序后期维护

public class ExtendsDemo01 {public static void main(String[] args) {Teacher t = new Teacher();t.name = "老大";t.age = 60;t.subject = "英语";t.teach();t.sleep();}
}//人  -->父类
class Person{public String name;public int age;public void sleep(){System.out.println("休息");}
}//教师类 ->子类
class Teacher extends Person{public String subject; //学科public Teacher(){}//教学public void teach(){System.out.println("教书育人!!!");}}//学生类 ->子类
class Student extends Person{public int grade; //成绩等级public Student(){}//学习public void study(){System.out.println("学习");}}

super关键字

super和this的区别：

this：

this指代对象，当前对象。

构造器的首行调用本类中的其他构造器。

区分局部与成员同名问题。

super：

super指代父类对象（子类内存中的父类对象）。

在子类的构造器首行，调用父类构造器。

如果没有显示调用父类的指定构造器，默认在子类构造器的首行调用父类的空构造。

this（）和super不能同时存在。

区分子父类中同名成员的问题：

默认就近原则。

指代父类的成员，需要通过父类对象调用父类成员 super。

如果不存在同名问题，当成员变量|方法，如果找到父类成员，默认省略super，如果找到子类成员，默认省略this。

注意：在存在父类继承的前提下，创建子类对象“先父类后子类”，先创建父类对象，再创建子类对象。

this与super都不能使用在静态环境中。

public class SuperDemo01 {public static void main(String[] args) {Zi zi = new Zi();zi.test();}}class Fu{public String name = "ash";public int age = 18;/*public Fu(){System.out.println("我是父类空构造");}*/public Fu(int a){System.out.println("我是父类带参构造"+a);}
}class Zi extends Fu{public String name = "Edd";//this调用当前类中的其他构造器public Zi(){this(1);System.out.println("我是子类空构造");}//子类构造器的首行super()调用父类中指定构造器public Zi(int i){super(10);System.out.println("带参构造器"+i);}public void test(){String name = "hahaha";System.out.println(name);  //就近原则System.out.println(this.name);  //Edd 当前类中的成员System.out.println(super.name);  //Ash  通过父类对象调用父类成员System.out.println(age);  //相当于省略了super.}
}