面向对象编程-爱代码爱编程
初识面向对象（oop）
本质：以类的方式组织代码，以对象的组织（封装）数据。
抽象
三大特性：
封装
继承
多态
回顾方法的定义
方法的定义
修饰符
返回类型
break与return区别
方法名：注意规范，见名知意
参数列表：（参数类型·，参数名）
异常抛出
方法的调用
静态方法
非静态方法
public class student {
public void say(){
System.out.println("学生说话了");
}
}
public class Demo01 {
public static void main(String[] args) {
//静态方法
// student.say();
//非静态方法
//实例化这个类
//对象类型 对象名=对象值
student student = new student();
student.say();
}
}
形参和实参
值传递和引用传递
public class Demo01 {
//值传递
public static void main(String[] args) {
int a=1;
System.out.println(a);
Demo01.change(a);
System.out.println(a);
}
//返回值为空
public static void change(int a) {
a=10;
}
}
public class Demo01 {
//引用传递
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name);
Demo01.change(person);
System.out.println(person.name);
}
public static void change(Person person) {
//person是一个对象
person.name = "qin";
}
}
class Person{
String name;//null
}
this关键字
类与对象的关系
类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物。
对象是抽象概念的具体实例。
创建与初始化对象
使用new关键字创建对象
使用new关键字创建对象的时候，除了分配内存空间之外，还会给创建好的对象进行默认初始化以及对类中构造器的调用。
类中的构造器也成为构造方法，是在进行创建对象的时候必须要调用的，并且构造器有以下两个特点：
1.必须和类的名字相同
2.必须没有返回类型也不能写void
使用new关键字，本质是在调用构造器。构造器用来初始化值 alt+insert 自动生成构造器。
注意：一旦定义了有参构造，无参构造就必须显式定义。
封装
高内聚：类的内部数据操作细节自己完成，不允许外部干涉
低耦合：仅暴露少量的方法给外部适用
意义·：提高程序安全性；隐藏代码实现细节；统一接口；系统可维护性增加了。
public class Application1 {
public static void main(String[] args) {
Student s1 = new Student();
s1.getName();
s1.setName("qin");
System.out.println(s1.getName());
s1.setAge(-1);
System.out.println(s1.getAge());
}
}
public class Student {
// 属性私有
private String name;
private int id;
private char sex;
private int age;
// 提供一些可以操作这个属性的方法1
//提供一些public的get,set方法
//get 获得这个数据
public String getName(){
return this.name;
}
public void setName(String name){
this.name= name;
}
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;
}else{
this.age = age;
}
}
}
继承
本质：对某一批类的抽象，从而实现对现实世界更好的建模
extends 扩展，子类是父类的扩展
java中类只有单继承，没有多继承。一个儿子只有一个爸爸，一个爸爸有多个儿子。
继承是类跟类之间的一种关系，除此之外，类和类之间的关系还有依赖，组合，聚合等
子类继承父类，用extends表示，会拥有父类的全部方法。
父类的private方法不能被继承
//public //protected //default //private.
在java中，所有的类都默认继承Object类。
public class Person /*extends Object*/{
public void say(){
System.out.println("说了一句话");
}
private int money = 1000000;
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
}
public class Teacher extends Person{
}
public class Student extends Person{
}
public class Application1 {
public static void main(String[] args) {
Student s1 = new Student();
s1.say();
Person person = new Person();
person.getClass();
}
}
super注意点：
1.super调用父类的构造方法，必须在构造方法的第一个
2.super必须只能出现在子类的方法或者构造方法中
3.super和this不能同时调用构造方法
super与this:
1.代表的对象不同。this：本身调用者这个对象 。super:代表父类对象的应用
2.前提：this:没有继承也能使用 。 super只能在继承条件下使用
3.构造方法：this() 本类的构造。super() 父类的构造
public class Application1 {
public static void main(String[] args) {
Student s1 = new Student();
// s1.test("qinjiang");
// s1.test1();
}
}
public class Person /*extends Object*/{
protected String name = "kuangshen";
public void print(){
System.out.println("person");
}
public Person() {
System.out.println("person无参执行了");;
}
}
public class Student extends Person{
public Student() {
//隐藏代码：调用了父类的无参构造
super(); //调用父类的构造器，必须要早子类构造器的第一行。 this也是一样
System.out.println("student无参执行了");
}
private String name = "qin";
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();
}
}
方法重写
public class Application1 {
public static void main(String[] args) {
// 方法的调用只和左边定义的数据类型有关
A a = new A();
a.test();
//A--test
// 父类的引用指向了子类
B b = new A();
B.test();
//B--test
}
}
public class A extends B{
public static void test(){
System.out.println("A--test");
}
}
public class B {
public static void test(){
System.out.println("B--test");
}
}
public class Application1 {
public static void main(String[] args) {
// 静态方法和非静态方法区别很大！
// 静态方法：方法的调用只和左边定义的数据类型有关
//非静态方法：重写
A a = new A();
a.test();
//A--test
// 父类的引用指向了子类
B b = new A(); //子类重写了父类的方法
b.test();
//A--test
}
}
public class A extends B{
public void test(){
System.out.println("A--test");
}
}
public class B {
public void test(){
System.out.println("B--test");
}
}
重写：需要有继承关系，子类重写父类的方法！
1.方法名必须相同
2.参数列表必须相同
3.修饰符：范围可以扩大但不能缩小 public>protected>default>private
4.抛出的异常：范围可以被缩小，不能被放大 classNotFoundException-->expection(大)
重写:子类的方法和父类必须要一致，方法体不同
为什么要重写？
1.父类的功能子类不一定需要，或者不一定满足！
alt+insert override;
多态
动态编译：类型：可扩展性更强
同一方法可以根据发送对象的不同而采用多种不同的行为方式
一个对象的实际类型是确定的，但是可以指向对象的引用类型有很多（父类，有关系的类）
注意：
1.多态是方法的多态，属性没有多态
2.父类和子类有联系，类型转换异常！classCastException!
3.存在的条件：继承关系 方法需要重写 父类引用指向子类对象 Father f1 = new son()
1.static方法属于类，它不属于实例
2.final 常量
3.private方法
public class Application1 {
public static void main(String[] args) {
//一个对象的实际类型是确定的
Student s1 = new Student();
//可以指向的引用类型就不确定了：父类的引用指向子类
//student能调用的方法都是自己的或者继承父类的
//person可以指向子类，但是不能调用子类独有的方法
Person s2 = new Student();
Object s3 = new Student();
s2.run();//子类重写了父类的方法，执行子类的方法
s1.run();
//对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！
s2.eat();//不能执行 因为person里没有父类方法
s1.eat();
}
}
public class Person /*extends Object*/{
protected String name = "kuangshen";
public void run(){
System.out.println("run");
}
}
public class Student extends Person{
public void run(){
System.out.println("son");
}
public void eat(){
System.out.println("eat");
}
}
instanceof
public class Application1 {
public static void main(String[] args) {
// Object>Person>Student
// Object>Person>Teather
// Object>String
Object object = new Student();
System.out.println(object instanceof Student);
System.out.println(object instanceof Person);
System.out.println(object instanceof Object);
System.out.println(object instanceof Teacher);
System.out.println(object instanceof String);
//true
//true
//true
//false
//false
//公式：System.out.println(X instanceof Y);
//能不能编译通过看X和Y有没有关系
}
}
public class Person /*extends Object*/{
protected String name = "kuangshen";
public void run(){
System.out.println("run");
}
}
//派生类
public class Teacher extends Person{
}
//派生类
public class Student extends Person{
}
类型转换
public class Application1 {
public static void main(String[] args) {
// //类型之间的转换
// //高 低 低转高不需要强制转换
Person s1 = new Student();
// s1.go(); 报错
//将这个person类型转换为Student类型，就可以使用Student类型的方法
Student student = (Student) s1;
student.go();
//子类转换为父类，可能丢失自己本来的方法
Student S2 = new Student();
S2.go();
Person person = student;
// person.go(); 不能执行
}
}
多态总结
1.父类引用指向子类对象
2.把子类转为父类，向上转型
3.把父类转换为子类，向下转型，强制转换
4.方便方法的调用，减少重复代码
抽象：封装，继承，多态
Static 关键字
抽象类
用abstract修饰
// abstract 抽象类 但是类单继承，接口可以多继承
public abstract class Action {
//约束~有人帮我们实现
//abstract,抽象方法，只有方法名字，没有方法实现！
public abstract void doSomething();
//1.不能new抽象类，只能靠子类去实现它
//2.抽象类中可以写普通方法
//3.抽象方法必须在抽象类中
//抽象的抽象
}
public class A extends Action{
//继承了抽象类的子类都必须实现抽象类的方法 除非子类也是抽象类
public void doSomething(){
System.out.println("A--test");
}
}
接口
普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有！
接口：只有规范！自己无法写方法~专业的约束！约束和实现分离
接口的本质是契约！
接口声明的关键词 interface
作用：
1.约束
2.定义一些方法让不同的人实现
3.public abstract
4.public static final
5.接口不能被实例化，接口中没有构造方法
6.implements可以实现多个接口
6.实现接口的类必须重写接口中的方法
// 类可以实现接口 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() {
}
}
public interface TimeService {
void timer();
}
//interface定义的关键字，接口都需要有实现类
public interface UserService {
//接口中的所有定义的方法都是抽象的 public abstract
//接口中定义的属性都是常量；
public static final int age = 99;
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
N种内部类
内部类就是在一个类的内部再定义一个类。
一个java类中可以有多个class类，但是只能有一个public class
1.成员内部类
public class Application1 {
public static void main(String[] args) {
Outer outer = new Outer();
//通过外部类来实例化内部类
Outer.Inner inter = outer.new Inner();
inter.in();
inter.getID();
}
}
public class Outer {
private int id = 10;
public void out(){
System.out.println("这是外部类的方法");
}
class Inner{
public void in(){
System.out.println("这是内部类的方法");
}
//获得外部类的私有属性
public void getID(){
System.out.println(id);
}
}
}
2.静态内部类
public class Application1 {
public static void main(String[] args) {
Outer outer = new Outer();
//通过外部类来实例化内部类
Outer.Inner inter = outer.new Inner();
}
}
public class Outer {
private int id = 10;
public void out(){
System.out.println("这是外部类的方法");
}
public static class Inner{
public void in(){
System.out.println("这是内部类的方法");
}
//获得外部类的私有属性
}
}
3.局部内部类
public class Outer {
//局部内部类
public void method(){
class Inner{
public void in(){
System.out.println("这是内部类的方法");
}
}
}
}
4.匿名内部类
public class Test {
public static void main(String[] args) {
//没有名字初始化类,不用将实例保存到变量中
new Apple().eat();
UserService1 userService1 = new UserService1(){
@Override
public void hello() {
}
};
}
}
class Apple{
public void eat(){
System.out.println("1");
}
}
interface UserService1{
void hello();
}