面向对象编程
回顾方法的调用
public class Demo01 {
public static void main(String[] args) {
//如果Student中的say方法是非静态的
//Student student = new Student();
Student.say();
}
//和类一起加载的
public static void a(){
b();
}
//类实例化 之后才存在
public void b(){
}
//(所以a去调用一个不存在的方法b，报错)
}
public class Student {
public static void say(){
System.out.println("测试测试测试");
}
}
值传递和引用传递
//值传递
public class Demo02 {
public static void main(String[] args) {
int a = 1;
System.out.println(a);
change(a);//仅仅是走了一个过程
System.out.println(a);
}
public static void change(int a) {
a = 10;
}
}
运行结果：
| 1 |
|---|
| 1 |
//引用传递:对象，本质还是值传递
public class Demo03 {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name);
change(person);//是通过Person类修改name的值
System.out.println(person.name);
}
public static void change(Person person) {
person.name = "测试";
}
}
class Person {
String name;
}
运行结果：
| null |
|---|
| 测试 |
构造器详解(@RequestBody)
-
类中的构造器也称构造方法，是在进行创建对象的时候必须要调用的。有以下两个特点：
- 必须和类名相同
- 必须没有返回值，也不能写void
-
作用
- 1.使用new关键字，本质是在调用构造器
- 2.构造器用来初始化值
-
注意点
- 一旦定义了有参构造，如果想使用无参构造，就必须显示定义一个无参构造
public class Student {
//一个类即使什么都不写，它也会存在一个方法
//显示的定义构造器
String name;
//实例化初始值
//1.使用new关键字，本质是在调用构造器
//2.构造器用来初始化值
public Student(){
this.name="sung";
}
//有参构造:一旦定义了有参构造，无参就必须显示定义
//(右击鼠标Generate+Constructor)
public Student(String name){
this.name=name;
}
}
public class Application {
public static void main(String[] args) {
//new 实例化了一个对象
Student student = new Student();
//Student()括号内为空，走的是无参构造，运行结果为sung
System.out.println(student.name);
}
}
封装详解
- 封装的优点：
- 提高程序的安全性，保护数据
- 隐藏代码的实现细节
- 统一接口
- 提高系统的可维护性
public class Demo01 {
public static void main(String[] args) {
Demo02 demo02 = new Demo02();
demo02.setName("sung");
System.out.println(demo02.getName());
demo02.setAge(330);
System.out.println(demo02.getAge());
}
}
public class Demo02 {
private String name;
private char sex;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if(age<120&&age>0) {
this.age = age;
}else{
System.out.println("输入年龄不合法");
}
}
}
继承
- Student虽为空，但是由于继承了Person，所以Person的属性和方法是可以通过Student去调用
- Person中的money虽然是私有的，可以通过get去获取
//父类
public class Person {
public void say(){
System.out.println("一句话");
}
private int money=1_0000_0000;
public int getMoney() {
return money;
}
}
//子类（什么都没有）
public class Student extends Person{}
//main方法
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.say();
System.out.println(student.getMoney());
}
}
运行结果：
| 一句话 |
|---|
| 100000000 |
Super详解
super注意点:
-
super调用父类的构造方法，必须在构造方法的第一个
-
super必须只能出现在子类的方法或者构造方法中!
-
super和 this不能同时调用构造方法!
Vs this:
- 代表的对象不同:
this:本身调用者这个对象
super:代表父类对象的应用 - 前提
this:没有继承也可以使用
super:只能在继承条件下才可以使用 - 构造方法
this():本类的构造
super():父类的构造!
//父类
public class Person {
protected String name="这是父类name";
public Person() {
System.out.println("Person无参执行了");
}
public void print(){
System.out.println("Person");
}
}
//子类
public class Student extends Person {
private String name = "这是子类name";
public Student() {
super();//隐藏代码：调用了父类的无参构造
//必须要在子类第一行
System.out.println("Student无参执行了");
}
@Override
public void print() {
System.out.println("Student");
}
public void test1(String name) {
System.out.println(name);//这是test方法name
System.out.println(this.name);//这是子类name
System.out.println(super.name);//这是父类name
}
public void test2() {
print();//Student
this.print();//Student
super.print();//Person
}
}
//main方法
public class Application {
public static void main(String[] args) {
Student student = new Student();
// student.test1();
// student.test2();
}
}
运行结果：
| Person无参执行了 |
|---|
| Student无参执行了 |
方法重写
重写:需要有继承关系，子类重写父类的方法!
-
方法名必须相同
-
参数列表必须相同
-
修饰符:范围可以扩大但不能缩小 Public>Protected>Default>Private
-
抛出的异常:范围，可以被缩小，但不能扩大; ClassNotFoundException --> Exception(大)
重写，子类的方法和父类必要一致; 方法体不同!
为什么需要重写:
1.父类的功能，子类不一定需要，或者不一定满足!
Alt + Insert ; override;
//父类
public class B {
public void test(){
System.out.println("B->test");
}
}
//子类
public class A extends B{
public void test(){
System.out.println("A->test");
}
}
//main方法
public class Application {
public static void main(String[] args) {
A a = new A();
a.test();
//方法重写
B b = new A();
b.test();
}
}
运行结果：
| A->test |
|---|
| A->test |
多态
多态注意事项：
-
多态是方法的多态，属性没有多态
-
父类和子类，有联系才可以，若没有会报出“类型转换异常！” ClassCastException!
-
存在条件：继承关系，方法需要重写，父类引用指向子类对象！ Father f1 = new Son();
不可以被重写的方法：
3.1 static 方法，属于类，它不属于实例；
3.2 final 常量；
3.3 private 方法；
//父类 public class Person { public void run() { System.out.println("father"); } }//子类 public class Student extends Person { @Override public void run() { System.out.println("son"); } public void eat() { System.out.println("eat"); } }//main方法 public class Application { public static void main(String[] args) { //可以指向的引用类型是不确定的：父类的引用指向子类 //Student能调用的方法都是自己的或者是父类的 Student s1 = new Student(); //Person 父类，可以指向子类，但不能调用子类独有的方法（方法重写） Person s2 = new Student(); //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！ s1.run(); s2.run(); ((Student) s2).eat(); //子类重写了父类的方法，执行子类的方法 } }运行结果：
son son eat
static关键字
public class Demo01 {
//2：赋初始值
{
System.out.println("匿名代码块");
}
//1:只执行一次~
static {
System.out.println("静态代码块");
}
//3
public Demo01() {
System.out.println("构造方法");
}
public static void main(String[] args) {
Demo01 d1 = new Demo01();
System.out.println("========================");
Demo01 d2 = new Demo01();
}
}
运行结果：
| 静态代码块 |
|---|
| 匿名代码块 |
| 构造方法 |
| ======================== |
| 匿名代码块 |
| 构造方法 |
abstract抽象类
//abstract 抽象类
public abstract class Abstract {
//约束~有人帮我们实现
//abstract，抽象方法，只有方法名字，没有方法实现！
public abstract void doSomething();
//1.不能new这个抽象类，只能靠子类去实现它：约束！
//2.抽象类里可以写普通方法
//3.抽象方法必须在抽象类中
//抽象的抽象：约束
public Abstract() {
System.out.println("存在构造器");
}
}
//抽象类的所有方法，继承了它的子类，都必须要实现它的方法~
public class A extends Abstract{
@Override
public void doSomething() {
}
}
//main方法（测试抽象类是否有构造器）
public static void main(String[] args) {
A a = new A();
}
接口的定义与实现
- 约束
- 定义一些方法，让不同的人实现~
- 定义方法默认都是public abstract
- 定义常量默认都是 public static final
- 接口不能被实例化~，接口中没有构造方法
- implements可以实现多个接口
- 必须要重写接口中的方法~
//interface 定义的关键字，接口都需要有实现类
public interface UserService {
//常量 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 time(Date yy_mm_dd);
}
//类 可以实现接口 implement 接口
//实现了接口中的类 必须要重写接口中所有的方法
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 time(Date yy_mm_dd) {
}
}
浙公网安备 33010602011771号