文章目录
一、面向对象编程概念
1、面向对象思想
2、什么是面向对象?
本质:以类的方式组织代码。以对象组织封装数据。
3、方法回顾和加深
1、方法定义回顾:
package com.oop.Demo01;
import java.io.IOException;
public class Demo01 {
public static void main(String[] args) {
}
// String:返回一个字符串
public static String sayHello(){
return "hello,world";// return代表方法结束,返回一个结果
}
//void:返回一个空值
public void print(){
return;
}
//int:返回一个整数
public int max(int a,int b){
return a>b ? a :b;//三元运算符
}
//读文件 抛出异常
public void readFile(String file)throws IOException {
}
}
2、静态方法和非静态方法的调用区别:
package com.oop.Demo01;
public class Demo02 {
public static void main(String[] args) {
// 静态方法 static
Student.say();
// 非静态方法
///实例化这个类 new
//对象类型 对象名 = 对象值
Student student = new Student();
student.say();
}
// static 和类一起加载的
public static void a(){
b();
}
//类实例化才存在
public static void b(){
}
}
package com.oop.Demo01;
//学生类
public class Student {
//非静态方法
public static void say(){
System.out.println("学生说话了");
}
public void hello(){
System.out.println("你好啊");
}
}
3、static方法不能调用不是静态方法的方法:
package com.oop.demo01;
public class Demo02 {
public static void main(String[] args) {}
// static 和类一起加载
public static void a(){
b();
// 报错 Non-static method 'b()' cannot be referenced from a static context
}
// 类实例化之后才存在
public void b(){}
}
4、形参和实参
package com.oop.Demo01;
public class Demo03 {
public static void main(String[] args) {
//不加 static
// int add = new Demo03().add(1, 2);
// System.out.println(add);
// 实际参数要与形式参数的类型要对应
int sum = Demo03.add(1, 2);
System.out.println(sum);
}
public static int add(int a,int b){
return a+b;
}
}
5、java都是值传递
package com.oop.Demo01;
//值传递
public class Demo04 {
public static void main(String[] args) {
int a =1;
System.out.println(a);
Demo04.change(a);
System.out.println(a);//1
}
//返回值为空
public static void change(int a){
a = 10;
}
}
6、引用传递
package com.oop.Demo01;
//引用传递:对象,本质还是值传递
public class Demo05 {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name);//null
Demo05.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
}
二、类与对象
1、类与对象的关系
2、创建与初始化对象
package com.oop.Demo02;
//一个项目应该只存一个main方法
public class Application {
public static void main(String[] args) {
//类:抽象的,实例化
//类实例化后会返回一个自己的对象
//student对象就是一个Student类的具体实例
Student xiaoming = new Student();
Student xh = new Student();
xiaoming.name = "小明";
xiaoming.age = 3;
xh.name = "小红";
xh.age = 3;
System.out.println(xiaoming.name);
System.out.println(xiaoming.age);
System.out.println(xh.name);
System.out.println(xh.age);
}
}
package com.oop.Demo02;
//学生类
public class Student {
//属性:字段
String name;//null
int age;//0
//方法
public void study(){
System.out.println(this.name+"在学习");
}
}
3、构造器
- 一个类即使什么都不写,它会存在一个方法。
package com.oop.Demo02;
public class Person {
public Person() {
}
}
-
作用1:使用new关键字,本质就在调用构造器。
-
作用2:初始化值
测试:
package com.oop.Demo02;
//一个项目只存在一个main方法
public class Application {
public static void main(String[] args) {
//实例化一个对象
Person person = new Person();
System.out.println(person.name);//libai
}
}
package com.oop.demo02;
public class Person {
String name;
//一个类即使什么都不写,它会存在一个方法
//显示的定义构造器
//实例化初始值
//1、使用new关键字,本质就在调用构造器
//2、初始化值
public Person(){
this.name = "libai";
}
}
- 有参构造: 一旦定义了有参构造,无参构造就必须显示定义
- 快捷键:Alt+Insert自动生成构造器
构造器总结:
1、和类名相同
2、没有返回值
作用:
1、使用new关键字,本质就在调用构造器
2、初始化值
注意点:定义有参构造之后,如果想使用无参构造,无参构造就必须显示定义
this. = 传进来的值;
package com.oop.Demo02;
public class Person {
//一个类即使什么都不写,他也会存在一个方法
//显示的定义构造器
String name;
int age;
//实例化初始值
//1.使用new关键字,本质是在调用构造器
//2.用来初始化值
public Person(){
}
//有参构造:一旦定义了有参构造,无参就必须显示定义
public Person(String name){
this.name = name;
}
//alt + insert
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
/*
public static void main(String[] args) {
//new 实例化一个对象
Person person = new Person("libai",23);
System.out.println(person.name);
}
构造器:
1.和类名相同
2.没有返回值
作用:
1.new本质在调用构造方法
2.初始化对象的值
注意点:
1.定义有参构造之后,如果想使用无参构造,显示的定义一个无参的构造
alt+insert
this. =当前对象传进来的值;
*/
4、内存图示
5、总结
三、面向对象三大特性
1、封装
意义:
1、提高程序的安全性
2、隐藏代码的实现细节
3、统一接口
4、系统可维护性增加了
package com.oop.demo04;
//类 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 getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
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 = 3;
System.out.println("年龄不合法");
}else {
this.age = age;
}
}
}
测试:
package com.oop;
import com.oop.demo04.Student;
/*
1.提高程序的安全性,保护数据
2.隐藏代码的实现细节
3.统一接口
4.系统可维护性增加了
*/
//一个项目应该只存一个main方法
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());
}
}
2、继承
子类继承了父类,就会拥有父类的全部方法。
在java中,所有的类都默认直接或间接的继承object类
Person父类:
package com.oop.demo04;
//父类
public class Person /*extends Object*/ {
public int money1 = 10_0000_0000;
private int money2 = 20_0000_0000;
public void say(){
System.out.println("hello");
}
public int getMoney2() {
return money2;
}
public void setMoney2(int money2) {
this.money2 = money2;
}
}
Student子类:
package com.oop.demo04;
//子类 ---学生 is 人
//子类继承了父类,就会拥有父类的全部方法。
public class Student extends Person {
//快捷键: Ctrl + H
}
Teacher子类:
package com.oop.demo04;
//子类 ---老师 is 人
public class Teacher extends Person{
}
测试:
package com.oop;
import com.oop.demo04.Student;
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.say(); //hello
System.out.println(student.money1); //10_0000_0000
//System.out.println(student.money2);//父类 private 不能继承
}
}
1、super、this
私有的东西无法被继承!
super注意点:
1.super调用父类的构造方法,必须在构造方法的第一个
2.super必须只能出现在子类的方法或者构造方法中!
3.super 和 this 不能同时调用构造方法
和this的对比:
-
代表的对象不同:
this:本身调用者这个对象 super:代表父类对象的应用
-
前提:
this:没有继承也可以使用 super:只能在继承条件才可以使用
-
构造方法
this();本类的构造 super();父类的构造
父类:
package com.oop.demo05;
//父类
public class Person /*extends Object*/ {
public Person() {
System.out.println("Person无参构造执行了");
}
protected String name = "父类的名字";
public void print(){
System.out.println("Person");
}
}
子类:
package com.oop.demo05;
//子类 ---学生 is 人
//子类继承了父类,就会拥有父类的全部方法。
public class Student extends Person {
//无参
public Student() {
//隐藏代码,调用了父类的构造器
super(); //调用父类的构造器,必须在子类构造器的第一行
System.out.println("Student无参构造执行了");
}
//有参
public Student(String name) {
this.name = name;
}
private String name = "子类的名字";
public void print(){
System.out.println("Student");
}
public void test1(){
print();
this.print();
super.print();
}
public void test(String name){
System.out.println(name);
System.out.println(this.name);
System.out.println(super.name);
}
}
测试:
package com.oop;
import com.oop.demo05.Student;
public class Application {
public static void main(String[] args) {
Student student = new Student();
/*
Person无参构造执行了
Student无参构造执行了
*/
student.test("传递的名字");
/*
传递的名字
子类的名字
父类的名字
*/
student.test1();
/*
Student
Student
Person
*/
}
}
2、方法重写
重写都是方法的重写,和属性无关
父类的引用指向子类是可以的
方法的调用只和左边的相关,即定义的数据类型有关
package com.oop.demo05;
//重写都是方法的重写,和属性无关
public class B {
public static void test(){
System.out.println("B->test");
}
}
package com.oop.demo05;
//重写都是方法的重写,和属性无关
public class A extends B {
public static void test(){
System.out.println("A->test");
}
}
测试:
package com.oop;
import com.oop.demo05.A;
import com.oop.demo05.B;
public class Application {
public static void main(String[] args) {
//方法的调用只和左边的相关
A a = new A();
a.test(); //A->test
//父类的引用指向子类是可以的
B b = new A();
b.test(); //B->test 类的优先级比对象大
}
}
快捷键:Alt + Insert—>Override Method
静态的方法和非静态的方法区别很大
package com.oop.demo05;
//重写都是方法的重写,和属性无关
public class B {
public void test(){
System.out.println("B->test");
}
}
package com.oop.demo05;
//重写都是方法的重写,和属性无关
public class A extends B {
@Override//重写 有功能的注释
public void test() {
System.out.println("A->test");
}
}
测试:
package com.oop;
import com.oop.demo05.A;
import com.oop.demo05.B;
public class Application {
//静态的方法和非静态的方法区别很大
public static void main(String[] args) {
// 方法的调用只和左边的相关
A a = new A();
a.test(); //A->test
// 父类的引用指向子类是可以的
B b = new A();// 子类重写了父类的方法
b.test(); //A->test
}
}
3、重写总结:
需要有继承关系,子类重写父类的方法
- 方法名必许相同
- 参数列表必须相同
- 修饰符:范围可以扩大但是不能缩小(Public->Protect->Default->Private)
- 抛出的异常:范围可以缩小但是不能扩大;ClassNotFoundException --> Exception(大)
重写:子类的方法和父类必须一致,方法体不同
为什么需要重写?
- 父类的功能不一定需要
- 父类的功能不一定满足
3、多态
package com.oop.demo06;
public class Person {
public void run(){
System.out.println("run");
}
}
/*
多态注意事项:
1.多态是方法的多态,属性没有多态
2.父类和子类,有联系 类型转换异常 ClassCastException!
3.存在条件:继承关系,方法需要重写,父类的引用指向子类对象 father f1 = new Son();
不能重写:
1.static静态方法,属于类,它不属于实例
2.final 常量;
3.private方法;
*/
package com.oop.demo06;
public class Student extends Person{
@Override
public void run() {
System.out.println("son");
}
public void eat(){
System.out.println("eat");
}
}
测试:
package com.oop;
import com.oop.demo06.Person;
import com.oop.demo06.Student;
//一个项目应该只存一个main方法
public class Application {
public static void main(String[] args) {
//一个对象的实际类型是确定的
// new Student;
// new Person;
//可以指向的引用类型就不确定了:父类的引用指向子类
//Student能调用的方法都是自己的或者继承父类的
Student s1 = new Student();
//Person 父类型,虽然可以指向子类,但是不能调用子类独有的方法
Person s2 = new Student();
Object s3 = new Student();
//对象能执行哪些方法,主要看对象左边的类型,和右边的关系不大
((Student) s2).eat();//子类重写了父类的方法,执行子类的方法
s1.run();
}
}
多态注意事项:
1.多态是方法的多态,属性没有多态
2.父类和子类,有联系 类型转换异常 ClassCastException!
3.存在条件:继承关系,方法需要重写,父类的引用指向子类对象 father f1 = new Son();
不能重写:
1.static静态方法,属于类,它不属于实例
2.final 常量;
3.private方法;
instanceof
X instanceof Y:用X和Y是否是父子关系来判断是否能编译通过。
package com.oop.demo07;
public class Person {
public void run(){
System.out.println("run");
}
}
package com.oop.demo07;
public class Student extends Person{
}
package com.oop.demo07;
public class Teacher extends Person{
}
package com.oop;
import com.oop.demo07.Person;
import com.oop.demo07.Student;
import com.oop.demo07.Teacher;
public class Application {
public static void main(String[] args) {
//Object->Person->student
//Object->Person->teacher
//Object->String
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(object instanceof String); //false
Person person = new Student();
System.out.println("============================");
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); //编译报错
Student student = new Student();
System.out.println("============================");
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); //编译报错
}
}
总结
一个对象的实际类型是确定的,可以指向的引用类型就不确定了
//new Student(); 确定的
//new Person(); 确定的
- 对象能执行哪些方法,主要看对象左边的类型,和右边关系不大
- 子类能够调用的方法只有自己的或者继承的
- 父类可以指向子类,但是不能调用子类独有的方法
- 父类/接口 变量名 = new 子类/实现类();
- Person s2 = newStudent(); //父类的引用指向子类
- 多态:父类的变量指向子类对象
条件:
- 父类引用指向子类的对象
- 把子类转换为父类,向上转型,会丢失一些方法
- 把父类转换为子类,向下转型,需要强制转换
- 方便方法的调用,减少重复的代码。
static
1、static变量、方法
1.static 跟类一起产生
2.静态方法不能调用非静态方法,非静态方法可以调用静态方法
3.类可以直接调用静态static变量和static方法
4.类的对象可以调用static和非static方法和变量
package com.oop.demo08;
// static 跟类一起产生
public class Student {
private static int age; //静态变量
private double score; //非静态的变量
//静态方法
public static void run(){
System.out.println("run");
// go(); 静态方法不能调用非静态方法
}
//非静态方法
public void go(){
System.out.println("go");
run(); //非静态方法可以调用静态方法
}
public static void main(String[] args) {
Student s1 = new Student();
System.out.println(s1.age);
System.out.println(s1.score);
System.out.println(Student.age); //类直接调用
//System.out.println(Student.score); //false
s1.run();
s1.go();
Student.run();
//Student.go; false类不能直接调用
run();
//go(); //false
}
}
2、static代码块
- 静态代码块:跟类一起产生,永久只执行一次
- 匿名代码块跟对象同时产生
- 先执行静态代码块,再执行匿名代码块,再执行构造方法
package com.oop.demo08;
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();
}
}
//运行结果:
/*
静态代码快
匿名代码快
构造方法
=============
匿名代码快
构造方法
*/
3、静态导入包
package com.oop.demo08;
//静态导入包
import static java.lang.Math.PI;
import static java.lang.Math.random;
public class Test {
public static void main(String[] args) {
System.out.println(random());
System.out.println(PI);
}
}
五、抽象类和接口
抽象类
总结1
- abstract抽象方法,只有方法名字,没有方法的实现;有人帮我们实现。
- 抽象类的所有方法,继承了他的子类,都必须要实现它得方法。
- 继承了抽象类的子类,必须实现父类的所有抽象方法。
- 类只能单继承,但是接口相当于多继承(接口多实现)。
总结2
- 不能new抽象类,只能靠子类去实现它:约束
- 抽象类里面可以有普通方法
- 抽象方法必须在抽象类中
- 抽象的抽象:约束~
- 存在构造器么?存在的意义?提高开发效率
实例
package com.oop.demo09;
//abstract:抽象类
public abstract class Action {
//约束~ 有人帮我们实现
//abstract:抽象方法,只有方法名字,没有方法的实现!
public abstract void doSomething();
}
package com.oop.demo09;
//抽象类的所有方法,继承了他的子类,都必须要实现它得方法
public class A extends Action{
@Override
public void doSomething() {
}
}
接口
~~
接口自己无法写方法,是专业的约束!约束和实现分离:面向接口编程
作用
- 接口是一个约束
- 定义一些方法,让不同的人实现
- 接口中的方法:public abstract
- 接口中的常量:public static final
- 接口不能被实例化~接口中没有构造方法
- implements可以实现多个接口
- 必须要实现接口中的方法
实例
接口1:
package com.oop.demo10;
// interface定义的关键字,接口都需要有实现类
public interface UserService {
//常量(全局性的)
public static final int AGE1 = 99;
//相当于
int AGE2 = 99;
//接口中的所有定义都是抽象的public
public abstract void add(String name);
//public abstract可以省略
public abstract void delete(String name);
public abstract void update(String name);
public abstract void query(String name);
}
接口2
package com.oop.demo10;
public interface TimeService {
void timer();
}
测试
package com.oop.demo10;
// 一个类可以实现接口 implements: 接口
// 实现了接口的类,就需要实现接口中的方法~
//利用接口可以实现伪多继承
public class UserServiceImp1 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() {
}
}
六、内部类
一个java类中可以有多个class类,但是只能有一个public class类
package com.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);
}
}
//一个java类中可以有多个class类,但是只能有一个public class类
class A{
public void main(String[] args) {
System.out.println();
}
}
//局部内部类
public void method(){
class Inner{
public void in(){
}
}
}
}
test:
package com.oop;
import com.oop.demo11.Outer;
public class Application {
public static void main(String[] args) {
//new 外部类
Outer outer = new Outer();
outer.out();
//通过外部类来实例化内部类
Outer.Inner inner = outer.new Inner();
inner.in();
inner.getID();
}
}
package com.oop.demo11;
public class Test {
public static void main(String[] args) {
// 没有名字初始化类,不用将实例保存到变量中
new Apple().eat();
// 必须重写
UserService userService = new UserService(){
@Override
public void hello() {
}
};
}
}
class Apple{
public void eat(){
System.out.println("eat");
}
}
//接口:
interface UserService{
void hello();
}