static关键字和继承
一、static基本概念
使用static关键字修饰成员变量表示静态的含义，此时成员变量由对象层级升级为类层级，也就是整个类只有一份并被所有对象共享，该成员变量随着类的加载准备就绪，与是否创建对象无关。
static关键字修饰的成员可以使用引用.的方式访问，但推荐类名.的方式。
public class People {
//私有化成员变量
private String name;
private int age;
//private String country;//隶属于对象层级，也就是每个对象都拥有独立的一份
public static String country;
//构造方法中调用set方法
public People() {}
public People(String name, int age, String country) {
setName(name);
setAge(age);
setCountry(country);
}
public void show() {
System.out.println("我是" + getName() +",今年" + getAge() +"岁了，来自" + getCountry());
}
//提供公有的get和set方法，并在方法体中进行合理值的判断；
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age > 0 && age < 150) {
this.age = age;
} else {
System.out.println("年龄不合理哦！");
}
}
public String getCountry() {
return country;
}
public void setCountry(String country) {
this.country = country;
}
}
public class PeopleTest {
public static void main(String[] args) {
//验证static关键字修饰的的静态成员是否与创建对象无关；
System.out.println("获取到的国籍信息是： " + People.country);
People p1 = new People("张飞",30,"China");
p1.show();
People p2 = new People("关羽",35, "China");
p2.show();
//验证static关键字修饰的静态成员（类成员）是否被所有对象共享
p1.country = "蜀国";
System.out.println("第一个对象的国籍是： " + p1.country);
System.out.println("第二个对象的国籍是： " + p2.country);
}
}
二、static使用方式
1、在非静态的成员方法中既能访问非静态的成员又能访问静态的成员。
（成员：成员变量+成员方法，静态成员被所有对象共享）
2、在静态成员方法中只能访问静态成员不能访问非静态成员。
（成员：成员变量+成员方法，因此此时可能没有创建对象）
3、在以后的开发中只有隶属于类层级并被所有对象共享的内容才能使用static关键字修饰（不能滥用static关键字）
public class StaticTest {
private int cnt = 1;//隶属于对象层级，也就是每个对象都拥有独立的一份
private static int snt = 2;//隶属于类层级，也就是所有的对象都共享同一份；
//自定义非静态的成员方法
public void show() {
System.out.println("cnt = " + cnt);
System.out.println("snt = " + snt);//静态成员被所有对象共享，this关键字可以省略；
}
//自定义静态的成员方法，使用类名.的方式访问
public static void test() {
//System.out.println("cnt = " + cnt);//静态成员方法中没有this关键字，
System.out.println("snt = " + snt);
}
public static void main(String[] args) {
StaticTest st = new StaticTest();
st.show();
System.out.println("---------------------");
//System.out.println("snt = " + snt);
StaticTest.test();
}
}
三、构造块和静态代码块（熟悉）
构造块：在类体中直接用{}括起来的代码块。
每创建一个对象都会执行一次构造块。
静态代码块：使用static关键字修饰的构造块。
静态代码块随着类加载时执行一次。
当需要在执行代码块之前随着类的加载做一些准备工作时，则编写代码到静态代码块中。
比如：加载数据库的驱动包等。
四、又见main方法
public static void main(String[] args){}
参数使用的举例：
public class MainTest {
public static void main(String[] args) {
System.out.println("参数数组中元素的个数时： " + args.length);
System.out.println("传递给main方法的实际参数为： ");
for (int i = 1; i < args.length; i ++) {
System.out.println("下标为" + i + "形参变量数值为： " + args[i]);
}
}
}
案例题目（重中之重）
public class Singleton {
//声明本类类型的引用指向本类类型的对象
private static Singleton sin = new Singleton();//饿汉式
//private static Singleton sin = null;//懒汉式
//私有化构造方法
private Singleton() {}
//提供公有的get方法负责将对象返回出
public static Singleton getInstance() {
if (null == sin) {
sin = new Singleton();
}
return sin;
}
}
public class SingletonTest {
public static void main(String[] args) {
//声明singleton类型的引用指向该类型的对象
//Singleton s1 = new Singleton();
//Singleton s2 = new Singleton();
//System.out.println(s1 == s2);//false;
//Singleton.sin = null;//是引用对象无效；
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
System.out.println(s1 == s2);
}
}
五、继承
继承概念：
当多个类之间有相同的特征和行为时，可以将相同的内容提取出来组成一个公共类，让多个类吸收公共类中已有特征和行为而在多个类型只需需要编写自己独有特征和行为的机制，叫做继承。
在java语言中使用extends（继承）关键字来表示继承关系。
继承意义：
使用继承提高了代码的复用性，可维护性及扩展性，是多态的前提条件。
继承特点：
1、子类不能继承父类的构造方法和私有方法，但私有成员变量可以被继承但是不能直接访问。
2、无论使用何种方式构造子类的对象时都会自动调用父类的无参构造方法，来初始化从父类中继承的成员变量，相当于在构造方法的第一行增加代码super()的效果。
3、使用继承必须满足逻辑关系：子类 is a 父类，也就是不能滥用继承。
4、java语言中只支持单继承不支持多继承，也就是一个子类只能有一个父类，但一个父类可以有多个子类。
六、方法重写
概念：从父类继承下来的方法不满足子类的需求时，就需要在子类重新写一个和父类一样的方法来覆盖从父类中继承下来的版本，该方式就叫做方法的重写（Override）.
Override：注解/标注，用于说明下面的方法是对父类方法的重写，若没有构成重写则编译直接报错。
方法重写的原则：
1、要求方法名相同，参数列表相同以及返回值相同，从java5开始允许返回子类类型。
2、要求方法的访问权限不能变小，可以相同或者变大。
3、要求方法不能抛出更大的异常（异常机制）。
七、Idea工具下载安装
下载链接：https://www.jetbrains.com/idea/
安装方式：一键式
package com.company.com.lagou.task08;
public class Animal {
private String name;
private String color;
public Animal() {}
public Animal(String name, String color) {
setName(name);
setColor(color);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public void show() {
//sout 回车 生成打印的快捷方式
//System.out.println();
System.out.println("名字： " + getName() + ",颜色： " + getColor());
}
}
package com.company.com.lagou.task08;
public class Dog extends Animal {
private int tooth;
public Dog() {
super(); //表示调用父类的无参构造
}
public Dog(String name, String color, int tooth) {
super(name, color);//表示调用父类的有参构造方法
setTooth(tooth);
}
public int getTooth() {
return tooth;
}
public void setTooth(int tooth) {
if (tooth > 0) {
this.tooth = tooth;
} else {
System.out.println("牙齿数量不合理哦");
}
}
@Override
public void show() {
super.show();//调用父类的show方法
System.out.println("牙齿数量是： " + getTooth());
}
}
package com.company.com.lagou.task08;
public class DogTest {
public static void main(String[] args) {
//使用无参构造方式dog类型的对象并打印特征
Dog d1 = new Dog();
d1.show();
//使用有参构造方式dog类型的对象并打印特征
Dog d2 = new Dog("旺财","白色",10);
d2.show();
}
}
七、又见构造块与静态代码块（笔试常考）
先执行父类的静态代码块，再执行子类的静态代码块；
先执行父类的构造块，再执行父类的构造方法体；
先执行子类的构造块，再执行子类的构造方法体；
package com.company.com.lagou.task08;
public class SuperTest {
{
System.out.println("supertest类中的构造块");
}
static {
System.out.println("supertest类中的静态代码块");
}
public SuperTest() {
System.out.println("supertest类中的构造方法体");
}
public static void main(String[] args) {
//使用无参方式构造对象
SuperTest st = new SuperTest();
}
}
package com.company.com.lagou.task08;
public class SubSuperTest extends SuperTest {
{
System.out.println("SubSuperTest类中的构造块");//2 B
}
static {
System.out.println("SubSuperTest类中的静态代码块");//1 A
}
public SubSuperTest() {
System.out.println("SubSuperTest类中的构造方法体");//3 C
}
public static void main(String[] args) {
//使用无参方式构造对象
SubSuperTest sst = new SubSuperTest();
}
}
八、常见的访问控制符
public修饰的成员可以在任意位置使用；
private修饰的成员只能在本类内部使用；
通常情况下，成员方法都使用public关键字修饰，成员变量都使用private关键字修饰。
package
在java语言中，用package来解决命名冲突的问题；
为了实现项目管理，解决命名冲突以及权限控制的效果。
定义包的规范：
如果各个公司或者开发组织的程序员都随心所欲的命名包名的话，仍然不能根本上解决命名冲突的问题，因此，在指定包名的时候应该按照一定的规范。
org.apache.commons.lang.StringUtil
其中StringUtil是类名，而org.apache.commons.lang是多层包名，其含义如下，org.apache表示公司或组织的信息（是这个公司（或组织）域名的反写）；common表示项目的名称信息；lang表示模块的名称信息；
使用import关键字导入包；
使用import关键字导入静态成员，从java5.0开始支持。
九、final关键字
概念：本意为“最终的，不可改变的”，可以修饰类，成员方法以及成员变量。
1、final关键字修饰类体现在该类不能被继承，主要用于防止滥用继承，比如：java.lang.String类等。
2、final关键字修饰成员方法体现在该方法不能被重写但可以被继承，主要用于防止不经意间造成重写，比如：java.text.Dateformat类中的format方法等。
3、final关键字修饰成员变量提现在该变量必须初始化且不能改变。主要用于防止不经意间造成改变，如：java.lang.Thread类中的MAX_PRIORITY等。
package com.company.com.lagou.task08;
public class FinalClassTest {
// private final int cnt = 1;//显示初始化
private final int cnt;
/*
{
cnt = 2;//构造块中进行初始化
}*/
public FinalClassTest() {
cnt = 3;//构造方法体内进行初始化
}
public static void main(String[] args) {
FinalClassTest fct = new FinalClassTest();
System.out.println("fct.cnt = " + fct.cnt);
}
}
在以后的开发中很少单独使用final关键字来修饰成员变量，通常使用public static final 关键字共同修饰成员变量来表达常量的含义，常用的命名规范要求是所有字母都要大写，不同的单词之间采用下划线连接。
public static final double PI = 3.14
十、任务总结
继承
访问控制
浙公网安备 33010602011771号