一、面向对象
面向过程：步骤清晰，第一步做啥，第二步做啥
面向对象：分类的思维模式（属性+方法就是一个类）
面向对象编程OOP：本质是以类的方式组织代码，以对象的组织封装数据
- 抽象
- 对象是具体的事物，类是抽象的
- 先有类后有对象，类是对象的模板
三大特性：封装、继承、多态
二、方法回顾和加深
-
如果a是静态方法，b不是静态方法，则a不能直接调用b
-
调用静态方法和非静态方法
//学生类 public class Student { //静态方法 public static void say(){ System.out.println("学生说话了"); } //非静态方法 public void sing(){ System.out.println("学生唱歌了"); } }public class Demo02 { public static void main(String[] args) { //调用静态方法 Student.say(); //调用非静态方法 //实例化这个类 //对象类型 对象名 = 对象值(变成了实例化对象); Student student = new Student(); student.sing(); } } -
值传递和引用传递
//值传递 public class Demo04 { public static void main(String[] args) { int a=1; System.out.println(a);//1 Demo04.change(a); System.out.println(a);//1 } //返回值为空 public static void change(int a){ a = 10; } }//引用传递：对象，本质还是值传递 public class Demo05 { public static void main(String[] args) { Person person = new Person(); System.out.println(person.name);//null Demo05.change(person); //change(person); System.out.println(person.name);//Suncx } public static void change(Person person){ //person是一个对象，指向----->Person person = new Person(); //具体的人可以改变属性 person.name = "Suncx"; } } //定义了一个类，有一个属性name class Person{ String name; }
三、对象的创建分析
类是一种抽象的数据类型，它是对某一类事物的整体描述/定义，但不代表某一个具体的事物
对象是抽象概念的具体实例
-
使用new关键字创建对象
public class Application { public static void main(String[] args) { //类：抽象的，需要实例化 //类实例化后会返回一个自己的对象 //student对象就是一个Student类的具体实例 Student xiaoming = new Student(); Student xiaohong = new Student(); xiaoming.name = "小明"; xiaoming.age = 3; xiaohong.name = "小红"; xiaohong.age = 3; System.out.println(xiaoming.name); System.out.println(xiaoming.age); System.out.println(xiaohong.name); System.out.println(xiaohong.age); } } -
使用new关键字创建的时候，除了分配内存空间外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用
-
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。
-
构造器的特点：
- 必须和类的名字相同
- 必须没有返回值，也不能写void
-
构造器的作用：
- 使用new关键字，本质是在调用构造器使用new关键字，本质是在调用构造器
- 初始化对象
- 一旦定义了有参构造器，无参构造就必须显示定义
public class Person { //一个类即使什么都不写，他也会存在一个方法 //显示定义构造器 String name; //构造器作用 //1.使用new关键字，本质是在调用构造器 //2.初始化对象 //3.一旦定义了有参构造，无参构造就必须显示定义 public Person(){ this.name = "Suncx"; } //有参构造 public Person(String name){ this.name = name; } //alt +insert //快捷生成构造器 }
四、面向对象三大特征
1. 封装
“高内聚，低耦合”
高内聚就是类内部数据操作细节自己完成，不允许外部干涉；
低耦合是仅暴露少量方法给外部使用
封装（数据的隐藏）：禁止直接访问一个对象中数据的实际表达，而应该是通过操作接口来访问。
属性私有，通过get/set方法得到
-
封装的意义：
- 提高程序的安全性，保护数据
- 隐藏代码的实现细节
- 统一接口
- 系统可维护性增加了
//类 public class Student { //属性私有 private String name;//名字 private int id; private int age; private char sex; //提供一些可以操作这些属性的方法 //提供一些public的get、set方法 //get获得这个数据 public String getName(){ return this.name; } //set给这个数据设置值 public void setName(String name){ this.name = name; } //alt+insert 会自动生成get、set方法 public int getAge() { return age; } public void setAge(int age) { if(age>120||age<0){ //安全性检测 this.age = 3; }else { this.age = age; } } } import com.oop.demo04.Student; //一个项目应该只存在一个main方法 public class Application { public static void main(String[] args) { Student s1 = new Student(); String name = s1.getName(); s1.setName("Suncx"); System.out.println(s1.getName()); s1.setAge(999);//不合法数据 System.out.println(s1.getAge()); } }
2. 继承
继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
extends的意思是“扩展”。子类是父类的扩展
Java中类只有单继承，没有多继承
继承是类与类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类使用关键字extends来表示
子类和父类之间，从意义上来讲应该具有“is a”的关系
-
object类
在Java中，中所有类都直接或间接继承object类
import com.oop.demo05.Person; //一个项目应该只存在一个main方法 public class Application { public static void main(String[] args) { Person person = new Preson(); person.getClass();//object类中的方法，Person类中并没有 } } -
super
私有的东西无法被继承
子类中调用父类中也有的方法时用super
super注意点： 1.super调用父类的构造方法，必须在构造方法的第一个 2.super必须只能出现在子类的方法中或者构造方法中 3.super和this不能同时调用构造方法 VS this: 代表对象不同： this：本身调用者这个对象 super：代表父类对象的应用 前提： this：没有继承也可以使用 super：只能在继承条件下才可以使用 构造方法： this()：本类的构造 super()：父类的构造// 人：父类 //在java中所有类都直接或间接继承object类 public class Person { public void say(){ System.out.println("说了一句话"); } private int money = 10_0000_0000; protected String name = "Suncx"; public void print(){ System.out.println("Person"); } public Person() { System.out.println("preson无参构造器"); }//学生 is 人：派生类（子类） //子类继承了父类，就会拥有父类的全部方法 public class Student extends Person { private String name = "Mangguo"; public void test(String name){ System.out.println(name); System.out.println(this.name); System.out.println(super.name); } public void print(){ System.out.println("Student"); } public void test1(){ print(); //student this.print();//student super.print();//person } public Student() {//无参构造器 //隐藏代码：默认调用了父类的无参构造 super();//调用了父类构造器，必须在子类第一行 System.out.println("student无参构造执行"); } }//默认先执行父类无参构造器 //再执行自己的 Student student = new Student(); //preson无参构造器 //student无参构造执行 -
方法重写
重写：需要有继承关系，子类重写父类的方法 1.方法名必须相同 2.参数列表必须相同 3.修饰符：范围可以扩大但是不能缩小 public>protected>default>private 4.抛出的异常：范围可以被缩小，但不能扩大 子类的方法和父类必须要一致；方法体不同 为什么需要重写？ 父类的功能子类不一定需要或者不一定满足 static方法属于类，不属于实例，不能重写 final常量 不能重写 private修饰的方法也不能重写package com.oop.demo05; //重写都是方法的重写，和属性无关 public class B { public void test(){ //第一次执行的结果是带有static的方法的结果 System.out.println("B-->test()"); } }package com.oop.demo05; public class A extends B{ //Override重写 @Override //注解，有功能的注释 public void test() { //第一次执行的结果是带有static的方法的结果 System.out.println("A-->test()"); } }import com.oop.demo05.A; import com.oop.demo05.B; //静态方法和非静态方法有很大区别 public class Application { public static void main(String[] args) { //静态方法的调用只和左边，定义的数据类型有关 //非静态方法：重写（关键词要是public） A a = new A(); a.test(); //A-->test() //A-->test() //父类的引用指向了子类 B b = new A(); //非静态方法：子类重写了父类的方法 b.test(); //B-->test() //A-->test() } }
3. 多态
多态即同一方法可以根据发送对象的不同而采取多种不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用类型有很多
- 多态存在的条件：
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象
- 多态注意：
- 多态是方法的多态，属性没有多态性
- 父类和子类，有联系 类型转换异常
public class Person {
public void run(){
System.out.println("run");
}
}
public class Student extends Person{
@Override
public void run() {
System.out.println("son");
}
public void eat(){
System.out.println("eat");
}
}
public class Application {
public static void main(String[] args) {
//一个对象的实际类型是确定的
//可以指向的引用类型就不确定了
//student能调用的方法都是自己的或者继承父类的
Student s1 = new Student();
//person父类，可以指向子类，但是不能调用子类独有的方法
Person s2 = new Student();//父类的引用指向子类
Object s3 = new Student();
//对象能执行哪些方法，主要看对象左边的类型
s2.run(); //run //son
s1.run(); //son
//s2.eat();
}
}
-
instanceof 判断一个对象是什么类型，比较转换
public class Application { public static void main(String[] args) { Object object = new Student(); System.out.println(object instanceof Student);//true System.out.println(object instanceof Person);//true System.out.println(object instanceof Object);//true System.out.println(object instanceof Teacher);//false } }
System.out.println(x instanceof y);是否能编译通过，看x和y有没有父子关系
public class Application {
public static void main(String[] args) {
//类型之间的转换：父--》子
//高 ----> 低
Person student = new Student();
//将student这个对象转换为Student类型，就可以使用Student类型的方法
//父类转换为子类要强制转换
((Student)student).go();
//子类转换为父类，可能丢失自己本来的一些方法
Person person = student;
}
}
五、static关键字
public class Student {
private static int age; //静态变量
private double score; //非静态变量
public static void main(String[] args) {
Student s1 = new Student();
System.out.println(Student.age);
//System.out.println(Student.score);报错，非静态变量不能用类名调用
System.out.println(s1.age);
System.out.println(s1.score);
}
}
public class Person {
{
//代码块（匿名代码块）
System.out.println("匿名代码块");
}
static {
//静态代码块，类一加载就执行，只执行一次
System.out.println("静态代码块");
}
public Person(){
System.out.println("构造方法");
}
public static void main(String[] args) {
Person person1 = new Person();
/*
静态代码块
匿名代码块
构造方法
*/
System.out.println("===============");
Person person2 = new Person();
/*
匿名代码块
构造方法
*/
}
}
//静态导入包
import static java.lang.Math.random;
public class Test {
public static void main(String[] args) {
//System.out.println(Math.random());
System.out.println(random());
}
}
六、抽象类和接口
1.抽象类
abstract修饰符可以用来修饰方法也可以用来修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类
抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类
抽象类，不能使用new关键字来创建对象，它是用来让子类继承的
抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的
子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类
//abstract 抽象类 extends:单继承/接口可以多继承
public abstract class Action {
//约束 有人帮忙实现
//抽象方法，只有方法名字，没有方法实现
public abstract void doSomething();
}
//抽象类的所有方法，继承了它的子类，都必须要实现它的方法
public class A extends Action{
@Override
public void doSomething() {
}
}
2.接口
普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有
接口：只有规范，自己无法写方法，专业的约束/ 约束和实现分离：面向接口编程
接口的本质是契约
声明类的关键字是class，声明接口的关键字是interface
//接口都需要有实现类
public interface UserService {
//接口中的所有定义都是抽象的 public abstract 可以不写
//public abstract void run();
//接口中定义的属性是静态的常量 public static final
int Age = 99;
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
public interface TimeService {
void timer();
}
//类 可以实现接口，通过implements接口
//实现了接口的类，就需要重写接口中的方法
//利用接口，侧面实现多继承
public class UserServiceImpl implements UserService,TimeService {
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
@Override
public void timer() {
}
}
- 接口的作用
- 约束
- 定义一些方法，让不同的人实现
- public abstract
- public static final
- 接口不能被实例化，接口中没有构造方法
- implements可以实现多个接口
- 必须要重写接口中的方法
七、内部类及OOP实践
内部类就是在一个类的内部再定义一个类
-
内部类
public class Outer { private int id = 10; public void out(){ System.out.println("这是外部类的方法"); } public class Inner{ //改成 public static class Inner 底下的id就拿不到了 public void in(){ System.out.println("这是内部类"); } //获得外部类的私有属性 public void getID(){ System.out.println(id); } } } //一个java类中可以有多个class类，但只能有一个public class 类 class A{ }import com.oop.demo10.Outer; public class Application { public static void main(String[] args) { Outer outer = new Outer(); //通过外部类实例化内部类 Outer.Inner inner = outer.new Inner(); inner.in(); inner.getID(); } } -
奇葩的一些
public class Test {
public static void main(String[] args) {
//没有名字实例化类（初始化类）
//不用将实例保存到变量中
new Apple().eat();
new UserService(){
@Override
public void hello() {
}
};
}
}
class Apple{
public void eat(){
System.out.println("1");
}
}
//接口
interface UserService{
void hello();
}
384
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
