初始面向对象(OPP)
-
面向过程思想
步骤清晰简单，第一步做什么，第二步做什么……
面向过程适合处理一些简单的问题
-
面向对象思想
物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。
面向对象适合处理复杂的问题，适合处理需要多人协助的问题
-
对于描述复杂的事物，从整体上合理分析，使用面向对象的思路来分析整个系统。但是具体到围观操作，仍然需要面向过程的思路去处理。
-
面向对象编程的本质：以类的方式组织代码，以对象的组织(封装)数据。
-
抽象
-
三大特性：封装，继承，多态
方法回顾和加深
方法的调用
-
静态方法
创建一个Stduent类，定义一个静态方法say();
//学生类 public class Student { public static void say(){ System.out.println("学生说话了"); }创建一个Demo01类，在该类中可直接调用say()方法
//Demo01 类 public class Demo01 { //main 方法 public static void main(String[] args) { Student.say(); }输出结果为：学生说话了
-
非静态方法
创建一个Stduent类，定义一个非静态方法say();
//学生类 public class Student { public void say(){ System.out.println("学生说话了"); }创建一个Demo01类，在该类中需通过实例化Student才可调用say()方法
//Demo01 类 public class Demo01 { //main 方法 public static void main(String[] args) { //实例化这个类 //对象类型 对象名=对象值 Student student=new Student(); student.say(); } //static ：和类一起加载 public static void A(){ //B(); }; // 类实例化 之后才存在 public void B(){ };输出结果为：学生说话了
两个静态方法可以相互调用，但静态方法不可直接调用非静态方法。因为static方法和类一起加载，非静态方法需要类实例化之后才存在。
-
形参和实参
-
值传递和引用传递
-
值传递：
//值传递 public class Demo02 { public static void main(String[] args) { int a=1; System.out.println("a="+a); Demo02.change(a); System.out.println("a="+a); } //返回值空 public static void change(int a){ a=10; } }这里两次a输出的值都为1；因为main方法中的a是实参，change中的a是形参，实参并没有改变。
-
引用传递
//引用传递 public class Demo03 { public static void main(String[] args) { Person person = new Person(); System.out.println(person.name); Demo03.change(person); System.out.println(person.name); } public static void change(Person person){ //person是一个对象：指向的---->Person person = new Person();这是一个具体的人，可以改变属性 person.name="早点"; } } //定义了一个person类，有一个属性：name class Person{ String name; //null }这里两次输出结果为null和早点。第一次输出为Person类中name的默认值。第二次输出通过change方法对Person类中的name的值进行了修改，故第二次输出结果为早点。
-
-
this关键字
对象的创建分析
-
使用new关键字创建对象
创建一个Student类
//学生类 public class Student { //属性：字段 String name; //null int age; //0 //方法 public void study(){ System.out.println(this.name+"在学习"); } }在Application类中实例化和调用Student
//一个项目应该只存一个main方法 public class Application { public static void main(String[] args) { //类是抽象的，需要实例化 //类实例化后会返回一个自己的对象 //student对象就是一个Student类的具体实例 Student xiaoming = new Student(); Student xh = new Student(); xiaoming.name="小明"; xh.name="小红"; xiaoming.age=3; xh.age=3; System.out.println(xiaoming.name); System.out.println(xiaoming.age); System.out.println(xh.name); System.out.println(xh.age); xh.study(); xiaoming.study();小结：
- 类是抽象的，需要实例化
- 类实例化后会返回一个自己的对象
- student对象就是一个Student类的具体实例
-
使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用
-
一个类即使什么都不写，也会存在一个构造方法
定义一个Person类
public class Person { }在Appliation中实例化Person类
//一个项目应该只存一个main方法 public class Application { public static void main(String[] args) { //使用new关键词实例化了一个对象 Person person = new Person(); } }点击IDEA右上角的项目结构---->Modules---->Add Content Root，将out文件夹加入列表，out文件里可查看所有class文件，找到Person.class打开，源码如下，可看见构造方法已经存在
// // Source code recreated from a .class file by IntelliJ IDEA // (powered by FernFlower decompiler) // package com.oop.demo02; public class Person { public Person() { } } -
使用new关键字，本质是在调用构造器
-
构造器一般用来初始化值
-
无参构造
public class Person { //一个类即使什么都不写，也会存在一个构造方法 //显示的定义构造器 String name; //实例化初始值 //1.使用new关键字，本质是在调用构造器 //2.构造器一般用来初始化值 public Person(){ this.name="早点"; }; }public class Application { public static void main(String[] args) { //使用new关键词实例化了一个对象 Person person = new Person(); System.out.println(person.name); // } } -
有参数构造:一旦定义了有参构造，无参构造必须显示定义
public class Person { String name; //实例化初始值 public Person(){}; //有参构造：一旦定义了有参构造，无参构造必须显示定义 public Person(String name){ this.name=name; }; //快捷键：alt+inset }public class Application { public static void main(String[] args) { //使用new关键词实例化了一个对象 Person person = new Person("厉害"); System.out.println(person.name); } }
-
-
构造器的快捷键为Alt+insert
-
-
类中的构造器也成为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：
- 必须和类的名字相同
- 必须没有返回类型，也不能写void
-
构造器必须要掌握
小结
-
类与对象
类是一个模板：抽象。
对象是一个具体的实例
-
方法
定义、调用
-
对象的引用
引用类型： 基本类型(8)
对象是通过引用来操作的：栈---->堆
-
属性：字段 Field 成员变量
默认初始化：
数字： 0 0.0
char： u0000
boolean：false
引用：null
修饰符 属性类型 属性名=属性值！
-
对象的创建和使用
- 必须使用new关键字创建对象， 构造器 Person zaodian=new Person();
- 对象的属性 zaodian.name
- 对象的方法 zaodian.sleep()
-
类：
静态的属性 属性
动态的行为 方法
-
面向对象三大特性
封装
-
特点
-
高内聚，低耦合
-
属性私有，get/set 快捷键：Alt+insert
-
例子：
//类 private:私有 public class Student { //属性私有 private String name; //名字 private int id; //学号 private char sex; //性别 private int age; //年龄 //提供一些可以操作这个属性的方法 //提供一些public的get，set方法 //get 获得这个数据 public String getName(){ return this.name; } // set 给这个数据设置值 public void setName(String name){ this.name=name; } //快捷键： alt+insert public int getAge() { return age; } public void setAge(int age) { if (age>20 ||age<0){ this.age=3; }else{ this.age = age; } } }public class Application { public static void main(String[] args) { Student s1 = new Student(); s1.setName("早点"); System.out.println(s1.getName()); s1.setAge(999); System.out.println(s1.getAge()); } }
-
-
作用
- 提高程序的安全性，保护数据
- 隐藏代码的实现细节
- 统一接口
- 提高系统可维护性
继承
继承的特点
-
继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
-
继承是类与类之间的一种关系。除此之外，类与类之间的关系还有依赖、组合、聚合等。
-
继承关系的两个类，一个为子类(派生类)，一个为父类(基类)。子类继承父类，使用关键字extends来表示。
-
子类和父类之间，从意义上将应该具有”is a“的关系。
-
子类继承了父类，就会拥有父类的全部方法(public)
-
查看继承关系的快捷键： ctrl+H
-
在java中，所有类都直接或间接继承了Object类
-
举例：
父类Person
//人 public class Person { //public private default protected private int money=10_0000_0000; public int getMoney() { return money; } public void setMoney(int money) { this.money = money; } public void say(){ System.out.println("说了一句话"); } }子类Student和Teacher
public class Student extends Person{ //查看继承关系 ctrl+H } //Teacher is 人 public class Teacher extends Person{ }
super
创建Student类继承自Person类，测试主类为Application
-
属性的继承
public class Student extends Person{ private String name="夏夏";j public void test(String name){ System.out.println(name); System.out.println(this.name); System.out.println(super.name); } }public class Person { protected String name="早点"; }//一个项目应该只存一个main方法 public class Application { public static void main(String[] args) { Student student = new Student(); student.test("zaodian"); } }输出结果为：zaodian 夏夏 早点
-
方法的继承
public class Person { protected String name="早点"; public void print(){ System.out.println("Person"); } }public class Student extends Person{ private String name="夏夏"; public void print(){ System.out.println("Student"); } public void test1(){ print(); this.print(); super.print(); } }public class Application { public static void main(String[] args) { Student student = new Student(); student.test1(); } }输出结果为：Student Student Teacher
-
构造器
public class Person { public Person() { System.out.println("Person无参执行了"); } }public class Student extends Person{ public Student() { System.out.println("Student无参执行了"); } }public class Application { public static void main(String[] args) { Student student = new Student(); } }输出结果为：Person无参执行了，Student无参执行了
∴子类默认调用了父类的无参构造
-
注意点
super注意点： 1. super调用父类的构造方法，必须在构造方法的第一个 2. super 必须只能出现在子类的方法或者构造方法中 3. super和this不能同时调用构造方法！ Vs this： 代表的对象不同： this：本身调用者这个对象 super：代表父类对象的应用 前提 this：没有继承也可以使用 super：代表父类对象的引用 构造方法 this();本类的构造 super();父类的的构造！
方法重写
重写：需要有继承关系，子类重写父类的方法!
1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符：范围可以扩大但不能缩小：public>Protected>Default>private
4. 抛出的异常：范围可以被缩小，但不能扩大；
重写，子类的方法和父类必须一致，方法体不同！
为什么需要重写：
1.父类的功能，子类不一定需要，或者不一定满足
Alt+Insert : Override
举例：A类继承B类
//重写都是方法的重写，和属性无关
public class B {
public void test(){
System.out.println("B=>test()");
}
}
public class A extends B{
// Override 重写
@Override //注解：有功能的注释
public void test() {
System.out.println("A=>test");
}
}
public class Application {
//静态方法和非静态的方法区别很大
//非静态：重写
//
public static void main(String[] args) {
A a = new A();
a.test(); //A
//父类的引用指向的子类
B b=new A(); //子类重写的父类的方法
b.test();
}
}
输出结果为A=>test A=>test
多态
举例和注意点
-
多态是方法的多态，属性没有多态
-
父类的和子类有联系 类型转换异常 ClassCastException
-
多态存在条件：继承关系，方法需要重写，父类引用指向子类对象 Father f1=new Son();
-
static 方法属于类，不属于实例，没有多态；final 常量和private方法也没有多态
-
对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！
-
子类能调用的方法都是自己的或者继承父类的；父类可以指向子类，但是不能调用子类独有的方法，所以一个对象的类型是确定的，但可以指向对象的引用的类型有很多(父类)
-
动态实现：动态编译：类型：可扩展
instanceof (类型转换)
引用类型，可用来判断一个对象是什么类型
举例：Student,Teacher,Person,Application类
**System.out.println(x instanceof y); **判断编译是否可以通过
public class Person {
}
public class Student extends Person{
public void go(){
System.out.println("go");
}
}
// Object>Person>Student
// Object>person>Teacher
Object object = new Student();
//System.out.println(x instanceof y); //true
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(object instanceof String); //false
System.out.println("====================");
Person person = new Student();
System.out.println(person instanceof Student); //true
System.out.println(person instanceof Person); //true
System.out.println(person instanceof Object); //true
System.out.println(person instanceof Teacher); //
public class Teacher {
}
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.go();
//子类转换为为父类，可能会丢失自己的本来的一些方法
Person person = new Student();
person.go();
//类型之间的转换： 父--子
Person obj = new Student();
//student将这个对象转换成Student类型，我们就可以使用Student类型的方法了
((Student)obj).go();
}
}
/*
1.父类引用指向子类的对象
2.把子类转换为父类，向上转型；
3.把父类转换为子类，向下转换： 强制转换
4.方便方法的调用，减少重复的代码！简洁代码
- 类型转换的特点：
- 父类引用指向子类的对象
- 把子类转换为父类，向上转型；
- 把父类转换为子类，向下转换： 强制转换
- 方便方法的调用，减少重复的代码！简洁代码
static
-
final之后，断子绝孙（被final修饰的类不可再被继承）
-
代码块和静态代码块
代码块加载顺序：
- 静态代码块，且仅执行一次，可用来赋初值
- 匿名代码块
- 构造方法
public class Person { { //2.第二加载代码块（匿名代码块） System.out.println("代码块"); } static{ //1.第一加载静态代码块,仅执行一次，可用来赋初始值 System.out.println("静态代码块"); } //3.第三加载 public Person() { System.out.println("构造方法"); } public static void main(String[] args) { Person person = new Person(); System.out.println("================="); Person person1 = new Person(); } } -
导入包时，加上static修饰
package com.oop.demo07; //静态导入包 import static java.lang.Math.PI; import static java.lang.Math.random; public class Test { public static void main(String[] args) { System.out.println(Math.random()); //没有静态导入包时 System.out.println(random()); //静态导入后可直接使用 System.out.println(PI); } }
抽象类和接口
抽象类
定义一个抽象类Action
//abstract 抽象类 类：单继承~ （接口可以多继承）
public abstract class Action {
//约束~有人帮我们实现
//abstract ,抽象方法，只有方法名字，没有方法的实现
public abstract void doSomething();
//1.不能new这个抽象类，只能靠子类去实现它：约束！
//2.抽象方法必须在抽象类中，抽象类中可以写普通的方法
}
定义一个A类继承Action
//抽象类的所有方法，继承了它的子类，都必须要实现它的方法~
public class A extends Action{
@Override
public void doSomething() {
}
}
接口
声明类的关键字是class，声明接口的关键字是interface
-
通俗解释：
- 递进关系：
- 普通类：只有具体实现
- 抽象类：具体实现和规范(抽象方法)都有
- 接口：只有规范！自己无法写方法专业的约束！约束和实现分离：面向接口编程
- 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是……则必须能……”，接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。
- 递进关系：
-
注意点和性质:
定义两个接口TimeService和UserService，类UserServiceImpl去实现接口
//抽象的思维 Java 架构师 //interface 定义的关键字， 接口都需要有实现类 public interface UserService { //接口中的常量 public static final public static final int age=99; //接口中的所有定义其实都是抽象的 public abstract void add(String name); void delete(String name); void update(String name); void query(String name); }public interface TimeService { void timer(); }
//抽象类：extends
//类 可以实现implements 接口
//实现了接口的类，就需要重写接口中的方法
//接口实现类命名Impl结尾 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() {
}
}
接口作用：
1. 约束
2. 定义一些方法，让不同的人实现~
3. public abstract 接口中的方法
4. public static final 接口中的变量
5. 接口不能被实例化，接口中没有构造方法
6. implements 可以实现多个接口
7. 必须要重写接口中的方法~
内部类和OOP实战
内部类就是在一个类的内部再定义一个类
-
成员内部类
-
静态内部类
-
局部内部类
//外部类 public class Outer { private int id; public void out(){ System.out.println("这是外部类的方法"); } //局部内部类 public void method(){ class Inner1{ } } //成员内部类 加static为静态内部类 public class Inner{ public void in(){ System.out.println("这是内部类的方法"); } //get外部类的私有属性 public void getID(){ System.out.println(id); } } }public class Application { public static void main(String[] args){ Outer outer = new Outer(); //通过这个外部类来实例化内部类 Outer.Inner inner = outer.new Inner(); inner.getID(); } } -
匿名内部类
public class Test { public static void main(String[] args) { //匿名内部类 没有名字初始化类,不用将实例保存到变量中 new Apple().eat(); } } class Apple{ public void eat(){ System.out.println("1"); } }
285
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
