public class Teacher {private String name;    // 教师名称private double salary;    // 工资private int age;    // 年龄
}

在上述代码中 name、salary 和 age 的作用域是 private，因此在类外部无法对它们的值进行设置。为了解决这个问题，可以为 Teacher 类添加一个构造方法，然后在构造方法中传递参数进行修改。代码如下：

// 创建构造方法，为上面的3个属性赋初始值
public Teacher(String name,double salary,int age) {this.name = name;    // 设置教师名称this.salary = salary;    // 设置教师工资this.age = age;    // 设置教师年龄
}

在 Teacher 类的构造方法中使用了 this 关键字对属性 name、salary 和 age 赋值，this 表示当前对象。this name=name语句表示一个赋值语句，等号左边的 this.name 是指当前对象具有的变量 name，等号右边的 name 表示参数传递过来的数值。
创建一个 main() 方法对 Teacher 类进行测试，代码如下：

public static void main(String[] args) {Teacher teacher = new Teacher("王峰",5000.0,45);System.out.println("教师信息如下：");System.out.println("教师名称："+teacher.name+"\n教师工资："+teacher.salary+"\n教师年龄："+teacher.age);
}

运行结果如下：

static关键字

static修饰变量

静态变量可以用于引用所有对象的公共属性(对于每个对象不是唯一的)。如：员工公司名称，学生所在的大学名称。

static修饰方法

如果在任何方法上应用static关键字，此方法称为静态方法。

静态方法属于类，而不属于类的对象。

可以直接调用静态方法，而无需创建类的实例。

静态方法可以访问静态数据成员，并可以更改静态数据成员的值。

java静态块

Java中的静态块主要有两个作用：

用于初始化静态数据成员。

它在类加载时在main方法之前执行。

代码块

包

包的作用

1.避免类重名

2.按照不同功能管理类

包（package）的命名规范

访问权限修饰符

面向对象特征

面向对象语言的三大特征 ：封装  继承  多态

封装：

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问 。

封装的好处：

1.隐藏类的实现细节只能通过规定方法访问
2.方便加入控制语句方便修改实现

public class Demo{
private String name;
public String getName (){
return name; }
public void setName(String name){this.name = name;}
}

继承

继承是面向对象程序设计不可缺少的设计思想，是实现代码可重用的根基，是提高代码可扩展性的主要途径。
1.继承是从已有的类中派生出新的类，新的类能吸收已有类的属性和行为，
并能扩展新的能力。
2.在JAVA中使用extends关键字来表示继承关系。JAVA不支持多继承，单继承使JAVA的继承关系很简单，一个类只能有一个直接父类。
3. 继承之后子类可以调用父类的所有非私有属性和非私有方法继承是代码重用的一种方式 ：

继承的形式：

// [访问权限修饰符][修饰符] 子类名 extends 父类名{子类体}
public class Animal{
public void eat(){}
}
public class Dog extends Animal{
public void play(){}
}

子类对象可以直接调用父类的方法，强调复用性
 Dog dog = new Dog (); 
 dog.eat();

继承的传递性

C 类从 B 类继承 ,B 类又从 A 类继承那么 C 类就具有 B 类和 A 类的所有非私有属性和非私有方法
当一个没有继承任何一个类时 ,jvm 会默认让类继承 Object 类
Object 是 java 为所有类提供的基类

继承中的构造方法

子类构造方法会先调用父类构造方法使用super关键字调用父类任意一个构造方法,必须写在构造方法的第一行
如果子类的构造方法中没有显式地调用基类构造方法，则系统默认调用基类无参数的构造方法。

super关键字用途

• 使用super关键字访问父类成员
• 用super.成员变量名来引用父类成员变量
• 用super.方法名（参数列表）访问父类的方法。
• 用super.构造方法(参数列表)访问父类构造方法
误区: 不要把super误认为是父类对象.在创建子类对象时, 不会创建父类对象. 只会将父类中的信息加载到子类对象中存储.

方法的重写(OverRide)

应用场景
当父类的方法实现不能满足子类需求时 , 可以对方法进行重写 ( override)
● 在子类中可以根据需要对从基类中继承来的方法进行重写。

方法重写规则
• 方法名相同、参数列表相同；
• 返回值类型相同；
• 访问权限不能小于父类权限 ;
注意：构造方法 , 静态方法不能重写 , 成员变量不存在重写

抽象类

抽象方法

1. 抽象方法是一种特殊的方法：它只有声明，而没有具体的实现 .
2.抽象方法必须用 abstract 关键字进行修饰 .
3. 如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。
4.抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法。
5. 用 abstract 修饰的类就是抽象类。如果某个类中包含有抽象方法，那么该类就必须定义成抽象类。

抽象类的特点 :

1. 抽象类不能被实例化，但可以有构造方法 , 因为抽象类中含有无具体实现的方法，所以不能用抽象类创建对象。
2. 抽象类只能用作基类，表示的是一种继承关系。继承抽象类的非抽象类必须实现其中的所有抽象方法，而已实现方法的参数、返回值要和抽象类中的方法一样。否则，该类也必须声明为抽象类。

多态

同一种事物，在不同时刻表现不同的状态
 多态存在的三个必要条件
1. 要有继承（包括接口的实现） ( 前提条件 )
2. 要有重写 ( 前提条件 )
3. 父类引用指向子类对象
 当编译期类型是父类，运行期类型是子类时，被称为父类引用指向子类对象

class Animal{
……
}
class Cat extends Animal{
……
}
class Dog extends Animal {……
}
Animal x = new Cat() //Animal 的引用指向Cat的对象

多态环境下对成员方法的调用

public class Animal{ void show() {System.out.println("Animal");
}public class Cat extends Animal{void show(){System.out.println("cat");}}
//调用的是子类中的方法 简单的说：编译看左边，运行看右边
Animal x = new Cat();x.show();

多态环境下对静态成员方法的调用

class Animal{
static void show() {
System.out.println("Animal");}
}
class Cat extends Animal {
static void show() {
System.out.println("Cat");}
}
//调用的是动物类中的静态成员方法。 简单的说：编译和运行都看左边。
Animal x = new Cat() x.show() ;

多态环境下对成员变量的调用

class Animal{int num = 3;
}
class Cat extends Animal {int num = 4;
}Animal x = new Cat() x.num; //调用的是动物类中的成员变量。

简单的说：编译和运行都看等号左边。
注意：变量不存在被子类覆写这一说法，只有方法存在覆写。

方法参数具有多态性

class Animal{void eat() {}
}
class Cat extends Animal{void eat() {}
}
class Dog extends Animal{void eat(){}
}//方法的形式参数类型是父类类型，而传递的实际参数可以是任意 子类的对象method(Animal animal){animal .eat();}

方法参数多态性的好处：提高代码的扩展

final关键字

final 用于声明属性，方法和类。
1.属性:定义就必须直接赋值或者在构造方法中进行赋值，并且后期都不能修改。
2.方法:子类里不可以重写。
•3.类:不能被定义为抽象类或是接口,不可被继承。

final属性赋值

在声明时同时赋值，往往与static一起使用。//数据不能在方法体中被修改
声明时不赋值，必须在构造方法中逐一赋值。
 总的原则：保证创建每一个对象的时候，final属性的值是确定的。

接口

public interface MyInterface {int num = 10;public void foo() ;public static void test(){}public default void test1(){}
}

接口的定义：

使用 interface 关键字用来声明一个接口。

[ 访问修饰符 ] interface 接口名称 [extends 其他的接口名 1,…. 其他的接口名 n]
{
// 声明常量 抽象方法 静态方法 默认方法
}

接口的使用：

类使用 implements 关键字实现接口。在类声明中， Implements 关键字放在class 声明后面。
[ 访问修饰符 ] class 类名 implements 接口名 1 ，接口名 2……{ }
结合继承：
[ 访问修饰符 ] class 类名 extends 父类名 implements 接口名 1 ，接口名 2……{ }

接口的特性：

1.接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字
2.接口中方法可以是抽象的,静态的,默认的
3.接口中声明的属性默认为 public static final 的
4. 接口不是被类继承了，而是要被类实现
5. 接口不能实例化对象
6. 与继承关系类似，接口与实现类之间存在多态性
7. 一个接口能继承其它多个接口