类和对象
1.类和对象是什么
类是一系列数据和方法的整体，它是对现实世界中一类具有共同特性的抽象，将这些共同特性使用成员变量和成员方法来表示。
对象是类实例化后的结果，如果说类就是一个流水线，而对象就是加工出的产品，但是不同对象可以有各自单独的数据。
2.类的定义
一类事物具有的共同属性称为类的成员变量，共同的方法称为类的成员方法
class 类名{
权限修饰符 成员变量
权限修饰符 成员方法
}
成员权限修饰
| 类修饰符 | 类修饰符 | 类修饰符 | 类修饰符 | |
|---|---|---|---|---|
| 访问位置 | private | protected | public | 默认 |
| 本类 | 可见 | 可见 | 可见 | 可见 |
| 同包其他类 | 不可见 | 可见 | 可见 | 可见 |
| 其它包的类 | 不可见 | 不可见 | 可见 | 不可见 |
| 子类 | 不可见 | 可见 | 可见 | 不可见 |
3.对象的创建
通过new关键字来生成一个新对象
示例：
Student stu = new Student();
4.类中的方法
4.1.构造方法
类中有一种特殊的方法，它的方法名和类名相同，没有返回值，而且只会在对象被创建时被调用一次，构造方法的作用是初始化。
构造方法相关知识点
- 如果类中没有定义任何构造方法，编译器会自动生成一个无参构造，但是如果自己定义了构造方法，编译器就不会帮我们定义构造方法。
- 构造方法支持重载；
- 可以通过super()调用父类的构造方法;
示例：
class Person{
public String name;
public int age;
//无参构造
public Person(){}
//带参构造
public Person(String name, int age){
this.name = name;
this.age = age;
}
}
4.2.静态方法
类中用static关键字修饰的类成员方法称之为静态方法，静态方法只会在类调用时被调用一次，可以通过类名加上.操作符访问，也可以通过对象访问。
注意事项：
- 静态方法中不能调用普通的成员方法，因为静态方法是在类加载的时候调用的，而普通方法是随对象调用的，对象没有创建好就不能调用普通的成员方法；
- 非静态方法可以调用静态方法。
示例：
class StaticClass{
public static void remember(){
System.out.println("No matter how far I go, I will never leave you!");
}
public void forget(){
System.out.println("I can't forget you!");
remember();
}
}
5.封装
封装通过权限修饰符对对象的属性和方法进行限制，对外部用户隐藏内部实现细节，让外部用户只能公开的方法访问到允许被访问的数据和方法，这样避免了外部操作对内部数据的影响，提高了程序的可维护性。
6.继承
继承是在父类的基础上进行扩展，实现了代码复用，但同时也破坏了类的封装特性
继承的关键字是extends,使用的格式如下：
class Base{}
class Derive extends Base{
public void newFunc(){}
}
继承的注意事项
- Java中只有单继承，也就是一个类只有一个直接父类；
- 构造方法的调用顺序是先调用父类的构造方法，再调用子类的构造方法；如果父类中没有无参构造方法，需要主动调用父类的构造，使用super(参数列表)来调用父类的构造方法；
示例：
class Base{
public int num;
public Base(int num){
this.num = num;
System.out.println("Base constructor");
}
}
class Derive extends Base{
public int num2;
public Derive(int num1, int num2){
super(num1);
this.num2 = num2;
System.out.println("Derive constructor");
}
}
- 如果父类和子类中的方法同名，子类方法会覆盖父类方法，如果需要使用父类方法就可以使用super调用父类方法；
示例：
public class Person {
public void doSomething(){
System.out.println("Person 做点事情");
}
}
public class Student extends Person{
public void doSomething(){
System.out.println("Student 做点事情");
//调用父类的doSomething方法
super.doSomething();
}
}
- 当子类和父类中的方法名相同，参数列表相同时，并且子类对方法体中的内容进行了修改，这种情况就称之为重写。
7.多态
多态指的是同一个方法，不同对象来调用会产生不同的结果，父类中定义一种规范化的方法，子类继承并重写，从而可以扩展出各种各样的子类。
存在条件
- 类之间具有继承关系；
- 子类重写了父类的方法；
- 通过父类的引用来调用子类；
8.抽象类
抽象类：用abstract关键字修饰的类
抽象方法：用abstract关键字修饰的方法，没有具体的实现；
8.1.抽象类和抽象方法的关系
有抽象方法的类一定是抽象类，而抽象类中可以没有抽象方法
8.2.抽象类的特点
- 抽象类不能用来实例化对象，因为抽象类是不完整的；
- 子类继承抽象类如果不重写抽象类中的抽象方法，子类也是抽象类，不能实例化对象；
- 抽象类中可以写普通的方法；
8.3.抽象类的作用
定义一种规范，让子类自己实现这种规范的方法，并通过抽象类的引用来指向子类，具有很好的扩展性。
8.4.示例
public abstract class Base{
//抽象方法定义规范
public abstract void func();
}
public class Derive extends Base{
public void func(){
System.out.println("Derive func");
}
}
public static void main(String[] args) {
Base a = new Derive();
a.func();
}
9.接口
1.接口是什么
一种规则的集合，所有的方法都没有实现，让继承接口的类来实现，对应的关键字为implements
2.特点
- 接口中方法必须定义为public abstract，即使不定义，它也是public abstract;
- 接口中只能定义常量,如果不加任何修饰符默认是public static final；
- 一个类可以实现多个接口，从而实现多继承；
- 一个类实现接口，就必须重写接口中定义的没有方法体的方法；
- 接口的修饰符只能是public和默认；
3.接口的多态传递
一个接口A被接口B继承，类C实现了接口B，则可以使用接口A指向类C实例化后的对象，同时类C必须实现接口A中的没有方法体的方法才能实例化对象。
示例：
public interface InterfaceA {
void run();
}
public interface InterfaceB extends InterfaceA{
void walk();
}
public class Person implements InterfaceB{
public void run(){
System.out.println("人可以跑");
}
public void walk(){
System.out.println("人可以走");
}
public static void main(String[] args) {
InterfaceA p = new Person();
p.run();
//向下转型
((Person)p).walk();
}
}
运行结果：
10.内部类
一种定义在类内部的类，内部类可以访问外部类中的所有成员和方法，但外部类不能直接访问内部类中的成员和方法，内部类的实例需要绑定在一个外部类对象上，内部类在实例化时需要借助外部类对象，示例如下：
public class Outer {
private int num;
public void outerFunc(){
System.out.println("Outer outerFunc");
}
class Inner{
public void func(){
num = 100;
outerFunc();
}
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
