面向对象编程（OOP）
面向对象编程（OOP）
狂神说java视频
java的核心思想就是OOP
初识面向对象
方法回顾和加深
方法的定义
package cn.dxj1016.oop;
import java.io.IOException;
//Demo01 类
public class Demo01 {
//核心方法main 方法：启动当前程序的方法 一个真正的程序只有一个main方法
public static void main(String[] args) {
}
/*
方法：
修饰符 返回值类型 方法名（...）{
//方法体
return 返回值；
}
*/
//return：结束方法，返回一个结果
public String sayHello() {
return "hello world";
}
public int max(int a,int b) {
return a > b ? a : b;//三元运算符！
}
//异常抛出
public void readFile(String file) throws IOException {
}
}
方法的调用
package cn.dxj1016.oop;
//学生类
public class Student {
//静态方法
public static void say() {
System.out.println("学生说话了");
}
//非静态方法
public void look() {
System.out.println("学生看黑板了");
}
}
package cn.dxj1016.oop;
public class Demo02 {
public static void main(String[] args) {
//静态方法的调用
Student.say();
//非静态方法的调用
//实例化这个类 new
//对象类型 对象名=对象值；
Student student = new Student();
student.look();
//调用静态方法
//实际参数和形式参数的类型要对应！
int add = Demo02.add1(1, 2);
}
//静态方法是和类一起加载的；非静态方法是在类实例化之后才存在的，所以静态的a方法中无法调用非静态的b；但非静态的b可以调用静态的a
public static void a() {
}
public void b() {
a();
}
public static int add1(int i, int j) {
return i+j;
}
}
值传递
package cn.dxj1016.oop;
//值传递
public class Demo03 {
public static void main(String[] args) {
int a = 1;
System.out.println(a);//1
Demo03.change(a);
System.out.println(a);//1
}
public static void change(int a) {
a = 10;
}
}
/*
可以断点调试一下
*/
引用传递
package cn.dxj1016.oop;
import cn.dxj1016.scanner.Demo05;
//引用传递：对象，本质还是值传递
//一个类中只能有一个public的class，但可以有多个class
public class Demo04 {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name);//null
Demo04.change(person);
System.out.println(person.name);//Jiao
}
public static void change(Person person) {
//person是一个对象：指向的-----》Person person=new Person（）；这是一个具体的人，可以改成属性！
person.name="Jiao";
}
}
//定义一个Person类，有一个属性：name
class Person {
String name;//null
}
类与对象的创建
package cn.dxj1016.oop.demo02;
//学生类
public class Student {
//属性：字段
String name;
int age;
//方法
public void study() {
System.out.println(this.name+"在学习");
}
}
package cn.dxj1016.oop.demo02;
//一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
//类：抽象的，实例化
//类实例化后会返回一个自己的对象
//student对象就是一个Student类的具体实例！
Student xiaoming = new Student();
Student xiaohong = new Student();
xiaoming.name = "小明";
xiaoming.age = 3;
System.out.println(xiaoming.name);
System.out.println(xiaoming.age);
xiaohong.name = "小红";
xiaohong.age = 4;
System.out.println(xiaohong.name);
System.out.println(xiaohong.age);
xiaohong.study();
xiaoming.study();
}
}
构造器详解
package cn.dxj1016.oop.demo02;
//java----->class
//打开class文件看看，步骤：打开项目结构---》Modules---->Add_Content ROot,将out文件夹加上
public class Person {
//一个类即使什么都不写，他也会存在一个方法
//显示的定义构造器
String name;
//无参构造函数
//实例化初始值
public Person() {
}
//有参构造：一旦定义了有参构造，无参就必须显示定义
public Person(String name) {
this.name = name;
}
/*
构造器：
1、和类名相同
2、没有返回值
作用：
1、使用new关键字，new本质在调用构造方法，必须要有构造器
2、初始化对象的值
注意点：
1、定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造
自动生成构造器的快捷键：
1、Alt+insert
*/
}
package cn.dxj1016.oop.demo02;
//一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
//new 实例化了一个对象
Person person = new Person();
System.out.println(person.name);//null
Person persion2 = new Person("Jiao");
System.out.println(persion2.name);//Jiao
}
}
创建对象内存分析
package cn.dxj1016.oop.demo03;
public class Pet {
public String name;
public int age;
public void shout() {
System.out.println("叫了一声");
}
}
package cn.dxj1016.oop;
import cn.dxj1016.oop.demo03.Pet;
public class Test {
public static void main(String[] args) {
Pet dog = new Pet();
dog.name = "旺财";
dog.age = 3;
dog.shout();
System.out.println(dog.name);
System.out.println(dog.age);
}
}
简单小结类和对象
-
类与对象：
1、类是一个模板：抽象。
2、对象是一个具体的实例
-
方法：定义、调用！
-
对应的引用
1、引用类型：基本类型（8）
2、对象是通过引用来操作的：栈---->堆
-
属性：字段Field 成员变量
默认初始化：数字：0 0.0；char：u0000；boolean：false；引用：null
修饰符：属性类型 属性名=属性值！
-
对象的创建和使用
必须使用new关键字创造对象，构造器 Person person=new Person();
对象的属性:person.name
对象的方法：person.sleep();
-
类：
静态的属性：属性
动态的行为：方法
封装详解
package cn.dxj1016.oop.demo04;
/**
* 1、提高程序的安全性，保护数据
* 2、隐藏代码的实现细节
* 3、统一接口
* 4、系统可维护增加了
*/
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;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age > 120 || age < 0) {
this.age = 3;
}else{
this.age = age;
}
}
}
package cn.dxj1016.oop;
import cn.dxj1016.oop.demo04.Student;
public class Test {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("Jiao");
String name = s1.getName();
System.out.println(name);
s1.setAge(999);//不合法的
System.out.println(s1.getAge());
}
}
什么是继承
package cn.dxj1016.oop.demo05;
//Person 人：父类
//在java中，所有的类，都默认直接或间接继承Object
public class Person {
// public
// protected
// private
// default
private int money=10_0000_0000;
public void say() {
System.out.println("说了一句话");
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
}
package cn.dxj1016.oop.demo05;
//学生 is 人：派生类，子类
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person{
}
package cn.dxj1016.oop.demo05;
//Teacher is 人：派生类，子类
public class Teacher extends Person{
}
package cn.dxj1016.oop;
import cn.dxj1016.oop.demo05.Person;
import cn.dxj1016.oop.demo05.Student;
public class Test {
public static void main(String[] args) {
Student student = new Student();
student.say();
System.out.println();
Person person = new Person();
person.getClass();
}
}
Super详解
super注意点：
- super调用父类的构造方法，必须在构造方法的第一个
- super必须只能出现在子类的方法或者构造方法中
- super和this不能同时调用构造方法
vs this：
-
代表的对象不同
this：本身调用者这个对象
super：代表父类对象的应用
-
前提：
this：没有继承也可以使用
super：只能在继承条件才可以使用
-
构造方法
this()：本类的构造
super()：父类的构造
package cn.dxj1016.oop.demo05;
//学生 is 人：派生类，子类
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person{
public Student() {
//隐藏代码：调用了父类的无参构造
super();//调用父类的构造器，必须要在子类构造器的第一行，否则报错
//this("hello");也要放在第一行
System.out.println("Student无参执行了");
}
public Student(String name) {
this.name=name;
}
private String name = "xiao";
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();
this.print();
super.print();
}
}
package cn.dxj1016.oop.demo05;
//Person 人：父类
//在java中，所有的类，都默认直接或间接继承Object
public class Person {
public Person() {
System.out.println("Person无参执行了");
}
protected String name = "Jiao";
//私有的东西子类无法继承，如果这里使用private，那么子类Student无法使用super.print()调用父类Person的print（）方法。
public void print() {
System.out.println("Person");
}
}
package cn.dxj1016.oop;
import cn.dxj1016.oop.demo05.Student;
public class Test {
public static void main(String[] args) {
Student student = new Student();
/*
执行结果：
deng
xiao
Jiao
*/
student.test("deng");
/*
Student
Student
Person
*/
student.test1();
}
}
/*
Person无参执行了
Student无参执行了
deng
xiao
Jiao
Student
Student
Person
*/
方法重写
package cn.dxj1016.oop.demo05;
//继承
public class A extends B{
// public static void test() {
// System.out.println("A=>test()");
// }
//Override 重写
@Override//注解：有功能的注解！
public void test() {
System.out.println("A=>test()");
}
}
package cn.dxj1016.oop.demo05;
//重写都是方法的重写，和属性无关
public class B {
// public static void test() {
// System.out.println("B=>test()");
// }
public void test(){
System.out.println("B=>test()");
}
}
package cn.dxj1016.oop;
import cn.dxj1016.oop.demo05.A;
import cn.dxj1016.oop.demo05.B;
public class Test {
//静态方法和非静态方法区别很大
public static void main(String[] args) {
//静态方法：方法的调用只和左边，定义的数据类型有关。
//非静态方法：重写
A a = new A();
a.test();
//父类的引用指向了子类
B b = new A();//子类重写了父类的方法
b.test();
}
}
/*
A=>test()
B=>test()
*/
/*
A=>test()
A=>test()
*/
总结
重写：需要有继承关系，子类重写父类的方法
- 方法名必须相同
- 参数列表必须相同
- 修饰符：范围可以扩大但不能缩小：public>Protected>Default>private
- 抛出异常：范围可以被缩小，但不能扩大；ClassNotFoundException ---->Exception（大）
重写，子类的方法和父类必须要一致；方法体不同
为什么需要重写：
- 父类的功能，子类不一定需要，或者不一定满足！
重写快捷键：Alt+Insert；override；
多态
package cn.dxj1016.oop.demo06;
public class Student extends Person{
@Override
public void run() {
System.out.println("son");
}
public void eat() {
System.out.println("eat");
}
}
package cn.dxj1016.oop.demo06;
public class Person {
public void run() {
System.out.println("run");
}
}
package cn.dxj1016.oop;
import cn.dxj1016.oop.demo06.Person;
import cn.dxj1016.oop.demo06.Student;
public class Test {
public static void main(String[] args) {
// 一个对象的实际类型是确定的
// Student student = new Student();
// Person person=new Person();
// 可以指向的引用类型就不确定了：父类的引用指向子类
// Student 能调用的方法都是自己的或者继承父类的
Student s1 = new Student();
// Person 父类型，可以指向紫烈，但是不能调用子类独有的方法
Person s2 = new Student();
Object s3 = new Student();
Person s4 = new Person();
s4.run();
s2.run();//子类重写了父类的方法，执行子类的方法
s1.run();
((Student)s2).eat();//可以强制转换类型
s1.eat();
// s2.eat();父类中没有该方法，所以不可以调用
//对象能执行哪些方法，只要看对象左边的类型，和右边关系不大。
}
}
/*
run
son
son
eat
eat
*/
多态注意事项：
- 多态是方法的多态，属性没有多态
- 父类和子类，有联系 类型转换异常！ClassCastException
- 存在条件：继承关系，方法需要重写。父类引用指向子类对象 father f1=new Son（）；
- 不能重写的情况
- static方法，属于类，不属于实例
- final常量；
- private方法；
instanceof和类型转换
package cn.dxj1016.oop.demo07;
public class Student extends Person{
public void go() {
System.out.println("go");
}
}
package cn.dxj1016.oop.demo07;
public class Person {
public void run() {
System.out.println("run");
}
}
package cn.dxj1016.oop.demo07;
public class Teacher extends Person{
}
package cn.dxj1016.oop;
import cn.dxj1016.oop.demo07.Person;
import cn.dxj1016.oop.demo07.Student;
import cn.dxj1016.oop.demo07.Teacher;
public class Test {
public static void main(String[] args) {
//类型之间的转化：父 子
// 高 低
Person student = new Student();
// student将这个对象转换为Student类型，我们就可以使用Student类型的方法了
// student.go();//没有转换之前，编译错误
Student st=(Student) student;
st.go();
Student student1 = new Student();
Person person=student1;
//person.go();//出错;说明，子类转换为父类，可能丢失自己的本来的一些方法
}
}
/*
// Object>String
// Object>Person>Teacher
// Object>Person>Student
Object object= new Student();
// System.out.println(X instanceof Y);//能不能编译通过
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);//false
//System.out.println(person instanceof String);//编译错误
System.out.println("=================================");
Student student = new Student();
System.out.println(student instanceof Student);//true
System.out.println(student instanceof Person);//true
System.out.println(student instanceof Object);//true
// System.out.println(student instanceof Teacher);//编译错误
//System.out.println(student instanceof String);//编译错误
*/
/*
执行结果：
true
true
true
false
false
=================================
true
true
true
false
=================================
true
true
true
*/
注意
- 父类引用指向子类的对象
- 把子类转换为父类，向上转型
- 把父类转换为子类，向下转型
- 方便方法的调用，减少重复的代码！简介
- 抽象：封装、继承、多态
static关键字详解
package cn.dxj1016.oop.demo08;
//static
public class Student {
private static int age;//静态变量 多线程
private double score;//非静态变量
public void run() {
go();//非静态方法可以调用静态方法；静态的在类建立的时候就加载到内存中了，但是非静态的是要在创建对象的时候才加载到内容中，所以在静态方法中调用非静态的方法的时候非静态方法还不存在，因此出现错误。
}
public static void go() {
// run();//静态方法不能调用非静态方法
}
public static void main(String[] args) {
Student student = new Student();
System.out.println(Student.age);
System.out.println(student.age);
System.out.println(student.score);
// System.out.println(Student.score);//错误，因为是非静态变量，不可以使用类名来调用
// run();//错误，因为run是非静态方法，不可以直接或者类名来调用
student.run();
Student.go();
go();
}
}
package cn.dxj1016.oop.demo08;
//如果在该类加上final修饰符，那么这个类就不可以被其它类继承，相当于断子绝孙
public class Person {
//2
{
//代码块（匿名代码块）
//程序在运行的时候，并不能主动去调用这些模块，创建对象的时候自动创建
System.out.println("匿名代码块");
}
//1 只执行一次
static{
//静态代码块
//类创建的时候创建
System.out.println("静态代码块");
}
//3
public Person() {
System.out.println("构造方法");
}
public static void main(String[] args) {
Person person1 = new Person();
System.out.println("===========================");
Person person2 = new Person();
}
}
/*
执行结果：
静态代码块
匿名代码块
构造方法
===========================
匿名代码块
构造方法
*/
package cn.dxj1016.oop.demo08;
//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Test {
public static void main(String[] args) {
System.out.println(random());
System.out.println(PI);
}
}
抽象类
package cn.dxj1016.oop.demo09;
//abstract 抽象类：类 extends:单继承 接口可以多继承
public abstract class Action {
//约束~有人帮我们实现
//abstract 抽象方法，只有方法名字，没有方法的实现
public abstract void doSomething();
}
package cn.dxj1016.oop.demo09;
//抽象类的所有方法，继承了他的子类，都必须要实现他的方法 除非子类也是abstract类型的
public class A extends Action{
@Override
public void doSomething() {
System.out.println("重写了抽象方法");
}
public static void main(String[] args) {
A a = new A();
a.doSomething();
}
}
特点
- 不能new这个抽象类，只能靠子类去实现他；约束
- 抽象类中可以写普通方法
- 抽象方法必须在抽象类中
- 抽象的抽象：约束
- 思考：
- 抽象类不能new，那他存在构造器吗？可以打开class看看；可以看到class中存在构造器
- 抽象类存在的意义？提高开发效率
接口的定义与实现
package cn.dxj1016.oop.demo10;
//抽象的思维-java
//interface 定义的关键字,接口都需要有实现类
public interface UserService {
//接口中定义的属性都是常量 public static final
int AGE=99;
//接口中的所有定义的方法其实都是抽象的 public abstract
public void run();
void add(String name);
void delete(String name);
void update(String name);
void select(String name);
}
package cn.dxj1016.oop.demo10;
public interface TimeService {
void time();
}
package cn.dxj1016.oop.demo10;
//类 可以实现接口 implements 接口
//实现了接口的类，就需要重写接口中的方法，否则报错
//多继承-利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService{
@Override
public void run() {
}
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void select(String name) {
}
@Override
public void time() {
}
}
接口的作用
- 约束
- 定义一些方法，让不同的人实现
- 方法都是public abstract
- 属性都是public static final
- 接口不能被实例化，接口中没有构造方法
- implements可以实现多个接口
- 必须要重写接口中的方法
内部类
package cn.dxj1016.oop.demo11;
public class Outer {
private int id=10;
public void out() {
System.out.println("这是外部类的方法");
}
public class Inner{
public void in() {
System.out.println("这是内部类的方法");
}
//获得外部类的私有属性
public void getID() {
System.out.println(id);
}
}
//局部内部类
public void method() {
class Inner1{
public void in() {
}
}
}
}
//一个java类中可以有多个class类，但是只能有一个public class类
class A{
}
package cn.dxj1016.oop.demo11;
public class Test {
public static void main(String[] args) {
//
Outer outer = new Outer();
//通过这个外部类来实例化内部类
Outer.Inner inner = outer.new Inner();
inner.in();
inner.getID();
//没有名字初始化类，不用将实例保存到变量中
new Apple().eat();
UserService userService = new UserService(){
@Override
public void hello() {
}
};
}
}
class Apple{
public void eat() {
System.out.println("1");
}
}
interface UserService{
void hello();
}
异常
什么是异常
异常分类
捕获和抛出异常
package cn.dxj1016.exception;
public class Test {
public static void main(String[] args) {
//在方法中如果直接throw抛出异常，那么遇到该异常就会停止运行，并抛出异常，如果方法上使用throws抛出异常，那么在语句使用try捕获异常并处理他，程序就不会停止，会继续运行
try {
new Test().test(1,0);
} catch (ArithmeticException e) {
e.printStackTrace();
}
int a=1;
int b=0;
//在捕获异常中，假设要捕获多个异常，要从小到大写，比如catch的时候如下面先写Exception后写Throwable是可以的，但是先写Throwable之后再写Exception，就会报错，因为Throwable包含了Exception
try {
//try监控区域
//Ctrl+Alt+T 选择代码，可以生成try
System.out.println(a / b);
} catch (Error e) {
//catch(想要捕获的异常类型) 捕获异常
System.out.println("Error");
} catch (Exception e) {
System.out.println("Exception");
} catch (Throwable t) {
System.out.println("Throwable");
} finally {
//处理善后工作
System.out.println("finally");
}
//finally 可以不要，假设IO，资源，关闭
}
public void test(int a, int b) throws ArithmeticException{
if (b == 0) {
//throw throws
throw new ArithmeticException();//主动的抛出异常,一般在方法中使用
}
System.out.println(a/b);
}
}
/*
执行结果
java.lang.ArithmeticException
at cn.dxj1016.exception.Test.test(Test.java:31)
at cn.dxj1016.exception.Test.main(Test.java:7)
Exception
finally
*/
自定义异常
package cn.dxj1016.exception.demo02;
//自定义的异常类
public class MyException extends Exception{
//传递数字>10；
private int detail;
public MyException(int a) {
this.detail = a;
}
//toString：异常的打印信息
@Override
public String toString() {
return "MyException{" +
"detail=" + detail +
'}';
}
}
package cn.dxj1016.exception.demo02;
public class Test {
//可能会存在异常的方法
static void test(int a) throws MyException {
System.out.println("传递的参数："+a);
if (a > 10) {
throw new MyException(a);//抛出
}
System.out.println("OK");
}
public static void main(String[] args) {
try {
test(11);
} catch (MyException e) {
System.out.println("MyException=>"+e);
}
}
}
总结
上一篇java数组
下一篇javaSE复习总结