- 前言
- 一、static 关键字
- 1.static 被该类的所有对象共享
- 2.static 被该类的所有对象共享
- 二、继承 extends
- 子类继承了父类，就能使用父类的属性，也可以重写父类的方法
- 三、final
- 1、final 修饰的类 不能被继承
- 2、final 修饰的方法 不能被重写
- 3、final 修饰的变量 就变成了常量(不能再次被赋值)
- 四、多态
- 多态的前提
- 1. 多态必须是继承或实现关系
- 2. 父类的变量 接收 子类的对象
- 3. 方法的重写(可有可无)
- 五、抽象类 abstract
- 六、接口 interface
- 接口的使用细节：
- 1. 无法创建对象
- 2. 接口里没有变量都是常量
- 3. 接口里方法都是抽象的
- 4. 类实现接口可以多实现
- ①、这里创建接口 子类
- ②、在主方法里测试
- 七、内部类
- 1、成员内部类
- 2、局部内部类
- 3、匿名内部类
- ①、匿名内部类(重点)(最常用)
- ②、在主方法里测试
- 4、Lambda 表达式
- 总结
前言
本篇文章主要讲Java面向对象的基础知识
static,继承,final,多态,抽象类,interface,内部类
一、static 关键字
1.static 被该类的所有对象共享 2.static 被该类的所有对象共享
①、先创建一个 Student 类
class Student {
public String name;
public int age;
public static String country;
}
②、主方法里 new Student
public static void main(String[] args) {
//static关键字
// 1. static 被该类所有的对象共享
// 2. static可以被类名调用
Student s = new Student();
s.name = "张三";
s.age = 23;
Student.country = "印度";//这里s.country 背景变色，可以直接用类名调用
String c = Student.country;//背景不变色
//static可以被类名直接调用
Student s1 = new Student();
s1.name = "李四";
s1.age = 24;
Student.country = "中国";
System.out.println(Student.country);//中国
System.out.println(Student.country);//中国
//static 被该类所有的对象共享,内存地址中只有一个country的地址
}
二、继承 extends
子类继承了父类，就能使用父类的属性，也可以重写父类的方法
①、先创建父类 Person ，子类 Student
class Person {
public String name;
public void show(){
System.out.println("我是："+name);
}
}
class Student extends Person{//子类继承了父类
@Override//子类重写了父类的方法
public void show() {
System.out.println("我是：" + name);
}
public void study() {//子类特有的方法
System.out.println("好好学习,天天向上");
}
}
②、主方法 分别 new 父类 、子类
public static void main(String[] args) {
Person p = new Person();
p.name = "老张";
p.show();//我是：老张
Student s = new Student();
s.name = "小明";
s.show();//我是：小明
}
三、final
1、final 修饰的类 不能被继承 2、final 修饰的方法 不能被重写 3、final 修饰的变量 就变成了常量(不能再次被赋值)
final class Person {
}
class Student {//这里报错 final 修饰的类 不能被继承
}
class Person1 {
public final void show() {
System.out.println("Person1");
}
}
class Student1 extends Person1{
}
class Person2 {
//报错 final 修饰的变量 就变成了常量(不能再次被赋值)
final int b = 10;//编译正常
}
四、多态
多态的前提 1. 多态必须是继承或实现关系 2. 父类的变量 接收 子类的对象 3. 方法的重写(可有可无)
①、创建 父类 Animal 子类 Cat，并让子类重写父类的方法
class Animal {
public void show() {
System.out.println("我是 Animal");
}
public void method() {
System.out.println("Animal 的 method 方法");
}
}
class Cat extends Animal {
@Override
public void show() {
System.out.println("我是 Cat");
}
public void catchMouse() {
System.out.println("Cat 抓 老鼠");
}
}
②、 主方法里创建父类，子类
public static void main(String[] args) {
Animal a = new Cat();
a.show(); // 我是 Cat
a.method(); // Animal 的 method 方法
//报错 //子类特有的方法
Cat c = new Cat();
c.show(); // 我是 Cat
c.method(); // Animal 的 method 方法
c.catchMouse(); // Cat 抓 老鼠
}
③、多态的应用：
能提高代码的 复用性 和扩展性。提高效率！
①、创建一个抽象父类 Animal 和 子类 Cat
继承了带有抽象方法的抽象类，子类必须要对父类里所有抽象方法进行重写，不然就会报错
abstract class Animal {
public void show() {
System.out.println("Animal");
}
public abstract void method();
}
class Cat extends Animal {//继承了带有抽象方法的抽象类，子类必须要对父类里所有抽象方法进行重写，不然就会报错
@Override
public void method() {
System.out.println("method");
}
}
②、主方法里 new 对象
很显然这里报错，抽象类abstract 的使用细节：
public static void main(String[] args) {
//报错，抽象类不能创建对象
}
六、接口 interface
接口的使用细节： 1. 无法创建对象
既然 有抽象方法的类：抽象类都不能创建对象，那么 接口就更不能创建对象了2. 接口里没有变量都是常量
①、在创建属性的时候 public static final 在接口中是默认的
因此变量属性变成了常量
②、接口中只有抽象方法，并且没有方法体；(没有{}及里边的东西)
所有的接口都会默认在方法前边给出 public abstract 关键字
3. 接口里方法都是抽象的
子类实现接口，要把接口中的所有抽象方法 全部重写4. 类实现接口可以多实现
①、子类可以多实现接口，因为接口里的方法都是抽象方法，
②、子类在实现的时候就要把父类的所有抽象方法全部重写
③、所以编译器知道子类在调用方法的时候是用的子类的方法
④、但是子类只能单继承，因为父类有同样的方法，子类不重写的话，
会导致编译器不知道你要用的是哪个父类的方法
①、这里创建接口 子类
interface Face {
void show();
//前边的 public abstract 是默认给出的关键字，编写时可忽略
void method();
}
class Student implements Face {
@Override
public void show() {
System.out.println("子类的show方法");
}
@Override
public void method() {
System.out.println("子类的method方法");
}
}
interface Face1 {
int a = 10;
void show();
}
interface Face2 {
void show();
}
class Student1 implements Face1, Face2 {
@Override
public void show() {
}
}
②、在主方法里测试
public static void main(String[] args) {
//编译报错 接口无法创建对象
Student s = new Student();
s.show(); //子类的show方法
s.method(); //子类的method方法
}
七、内部类
1、成员内部类
在类的 内部 里的 类
//成员内部类
class Student {
int age = 20;
class Study {
int age = 18;
public void show() {
System.out.println(age);
}
}
public void method() {
System.out.println(new Study().age);
}
}
2、局部内部类
在类的 方法 里的 类
//局部内部类
class Phone {
int a = 6666;
public void show() {
int a = 8888;
class applePhene {
final int a = 9999;
public void show(){
System.out.println(a);
}
}
}
}
3、匿名内部类
没有类名 在被调用时或自己调用自己的方法时被使用①、匿名内部类(重点)(最常用)
interface Face {
void show();
}
②、在主方法里测试
public static void main(String[] args) {
show(new Face() {
@Override
public void show() {
System.out.println("匿名内部类");
}
});
//lambda表达式：
show(()->{ System.out.println("Lambda：匿名内部类"); });
}
public static void show(Face f) {
f.show();
}
4、Lambda 表达式
总结
以上就是Java面向对象的基础知识
static,
继承 extends,
final,
多态,
抽象类 abstract,
接口 interface,
内部类
1.成员内部类
2.局部内部类
3.匿名内部类
虽然只写了个大概。。。后期慢慢的更新
希望有大佬带带我 狗头滑稽
