1.类:构造对象的模板
public class A{
} A类
2.类的实例:创建类对象
Scanner scanner = new Scanner(System.in); //创建Scanner的实例
3.封装:数据和行为组合在一个包中，数据和行为组合在一个包中。
//封装Dog类
package Object;
public class Dog {
String name;
String color;
Dog()
{
System.out.println("我是无参数的构造器");
}
Dog(int a)
{
System.out.println("我是有参数构造器");
}
public void eat()
{
System.out.println("我再吃东西");
}
public void sleep()
{
System.out.println("我在睡觉");
}
}
4.继承:通过扩展一个类来建立另外一个 类的过程称为继承
//Dog1 继承 Dog类
package Object;
public class Dog1 extends Dog{
Dog1()
{
System.out.println("调用无参数");
}
Dog1(int n)
{
super(200);
System.out.println("调用有参数的");
}
}
5.依赖： 如果一个类的方法操纵另一个 类的对象，我们就说一个类依赖于另一个类。
6.聚合：一个 Order 对象包含一些 Item 对象。聚合关系意味着类 A 的对象包含类 B 的对象。
7.对象变量:对一个对象的引用，并没有实际包含一个对象。
Date birthday;
Date deadline = new Date();
birthday = deadline;
这个两个变量已引用同一个对象。
8.类路径:项目Src下。
9.super,this详解
super() ---------->调用父类的无参构造方法，必须在构造方法的第一个
super------>必须只能出现在自雷的方法或者构造方法中
super和this不能同事调用构造方法
super.属性 -------->调用父类的属性和方法(不能调用私有的)
this.属性------->调用当前类的属性和方法
this()----------->本类的构造
10.方法重写
重写:需要有继承关系,子类重写父类的方法（方法体不同）
1.方法名必须相同
2.参数列表必须相同
3.修饰符:范围可以扩大 :public>protected>default>private （不能缩小
4.抛出的异常：范围可以缩小，但不能扩大 ----------->ClassNotFoundException ---->Exception(大)
11.多态
1.多态是方法的多态，属性没有多态
2.父类和子类，能转换
3.存在条件：继承关系，方法需要重写，父类引用指向子类对象 Person s2 = new student();
package OOP;
public class Person {
public void run(){
System.out.println("person");
}
}
package OOP;
public class student extends Person {
@Override
public void run() {
System.out.println("sutdent");
}
public void eat()
{
System.out.println("eat");
}
}
package OOP;
public class Application {
public static void main(String[] args) {
//一个对象的实际类型是确定的
//new student();
//new person();
//指向的引用类型就不确定： 可以指向Object,父类:person, student;
//s1 可以调用的方法(自己的或者继承父类的方法)
student s1 = new student();
//s2 不能调用子类独有的方法( 不能调用eat方法 s2.eat())
Person s2 = new student();
//需要强制转换后才可以调用, 子类转换为父类会丢失eat()方法。
//子类转为父类：向上转型
//父类转换为子类:向下转型
((student) s2).eat();
//重写了父类的方法，所以执行子类的run 方法。
s2.run();
Object s3 = new student();
}
}
12.捕获异常
- **检查性异常：**最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
- 运行时异常： 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
- 错误： 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。
package exception;
//类名不存在抛出异常
public class Demo1 {
public static void main(String[] args) {
try{
String name = "....";
Class cl = Class.forName(name);
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
13.Static关键字
package OOP;
public class StaticStudent {
//静态变量
private static String name;
private int age;
public void run(){
}
public static void go()
{
}
public static void main(String[] args) {
StaticStudent staticStudent = new StaticStudent();
staticStudent.age = 1;
System.out.println(staticStudent.age);
System.out.println(StaticStudent.name);
//能调用静态方法
go();
//不能调方法，类生成时还没有生成
//run();
}
}
package OOP;
public class StaticPerson {
//2
{
System.out.println("匿名代码块");
}
//1 静态方法只会执行一次 (跟对象是同时产生)
static {
System.out.println("静态代码块");
}
//3
StaticPerson()
{
System.out.println("构造方法");
}
public static void main(String[] args) {
StaticPerson staticPerson = new StaticPerson();
System.out.println("****************************");
StaticPerson staticPerson2 = new StaticPerson();
}
}
输出结果:
静态代码块
匿名代码块
构造方法
****************************
匿名代码块
构造方法
14.抽象类(abstrasct)
package OOP;
//abstract 抽象类 extends 只能单继承 (接口可以多继承)
public abstract class action {
//抽象方法,只有方法名字，不能实现
public abstract void doSomething();
//1.不能new这个抽象类，只能靠子类去实现。
//2.抽象类中可以写普通方法
//3.抽象方法必须在抽象类中
//思考 抽象类是否有构造方法？
}
15.接口
package OOP;
//interface 定义的关键字，接口都需要有实现类
public interface UserService {
//接口中的所有定义都是抽象的public
void run();
void add(String name);
}
package OOP;
//实现接口类 必须要重写接口的方法
public class UserServiceImpl implements UserService,TmpService{
@Override
public void run() {
System.out.println("run");
}
@Override
public void add(String name) {
System.out.println("add");
}
@Override
public void tmp() {
System.out.println("tmpservice");
}
}
package OOP;
public interface TmpService {
void tmp();
}