面向对象oop

定义：以类的方式组织代码，以对象来封装数据
特性：封装+继承+多态
注1》从认识论：先有对象（具体事物），后有类（对对象的抽象）
2》从代码运行角度：先有类后有对象，类是对象的模板
1》方法调用
package com.kuangstudy.oop;
public class opp1 {
//方法的调用（静态与非静态）
public static void main(String[] args) {…}

//static 方法与类建立时就一起产生了，可通过类名引用方法
public static void a(){};
//非static方法只有实例化new时才存在
public  void b(){};

}
2》参数的传递
21》值传递
22》引用传递：传弟的是对象，本质还是质传递
3》this代表当前类与当前对象
4》类与对象的关系：
41》类是对某一类事物整体描述不代表某一具体的事物
42》对象是某一抽象类的具体实例;

5》构造器
51》和类名相同，没有返回值
52》本质在调用构造方法，初始化对象的值;
注：定义了一个有参构造，那个无参构造必需显示定义
package com.kuangstudy.oop;
public class opp1 {
//一个类即使什么都不做，它也存在一个与类名相同的方法显示的构造器
String name;
int age;
//定义了一个有参构造，那个无参构造必需显示定义
public opp1(){} //无参构造器

public opp1(String name) {  //有参构造器，
  *****// ALT+Insert自动生成构造器*****
    this.name = name;
}

public opp1(String name,int age) { //有参构造器，
    this.name = name;
    this.age = age;
}

}
6》对象内存分析

7》封装：
71》提高调用类的安全性，保护数据
72》隐藏代码实现的细节
73》统一接口，提高可维护性
package com.kuangstudy.oop;

public class oopmain {
public static void main(String[] args) {
student s1=new student();
//其他的类属性私有后就不能直接实例化后用了;
s1.setName(“lj”);
System.out.println(s1.getName());

}

}

/*
ackage com.kuangstudy.oop;

public class student {
//属性私有，get/set,禁止直接访问一个对象中数据的表示，而是通过接口访问
private String name;
private int id;
private char sex; //封装一般是用于属性
// 属性私有后就不能直接补其他类实例化后用了，要用ALT+insert 自动生成get/set本属性方法
public String getName() {
return name;
}

public void setName(String name) {
    this.name = name;
}

public int getId() {
    return id;
}

public void setId(int id) {
    if (id > 9999 || id < 0) {
        this.id = 1;
    } else {
        this.id = id;
    }
}

public char getSex() {
    return sex;
}

public void setSex(char sex) {
    this.sex = sex;
}

}
*/
8》继承extends：
package com.kuangstudy.oop;
//student子类 继承父类person,拥有父类的pulic非private全部方法、属性
//在JAVA中所有的类都默认直接或间接继承object类
public class student extends person{
//查看当前类继承了什么类用 CTR+H
//java是单继承非多继承，一条线下来
}
9》super：
91》super调用父类的构造方法，必在构造方法的第一个
92》super必须只能出在子类的方法或构造方法中！
93>super和this不能同时调用构造方法

super vs this :
a>代表的对象不同：
this 调用本身，super代表父类对象的应用
b>前提：
this没有继承也可使用，super只能在继承条件下才能用
c>构造方法：
this() 本类的构造，super父类的构造

10》方法的重写：
a》重写是只方法的在继承的基础上
b>静态与非静态方法区别很大，重写只是对非静态方法有效; 子类重写了父类的方法
c>只能是public,不能是private;
d>方法名与参数列表相同(参加不要样是重截），方法体可不一样;
e>修饰符：范围可以扩大但不能综小，public>proected>Default>private
f>抛出异常：范围可以缩小不能扩大，ClassNotFoundException–>Exception(大）
g》ALT+Insert: override;
h>父类的方法子类不一定有需要或满足才要重写

11》多态：
a>方法的多态，属性没有多态,（父类的引用指向子类）
b>有继承关系才能转换ClassCastException!
c>方法需要重写，父类引用指向子类对象
d>static方法是属于类的不属于实例
e>final 是常量不能用
f>private方法是私有更不行？
g>同一方法可能根据发送对象的不同而采用不同的行为;

12》类 的类型转换（instanceOf)：
X instanceof Y
package com.kuangstudy.oop;

public class oopmain {
public static void main(String[] args) {
// Object>person>student
Object obj1=new student();
//判断obj1对象的类型？
System.out.println(obj1 instanceof student);
高 低
person obj=new student();
((student) obj).getClass(); //高转低要强转才能用子类方法
//父类的引用指向子类对象
//把子类转换为父类，向上转换可能丢失方法
//把父类转换为子类，向下转换强止转换
}
}

13》static:
a》static变量可真接用 ‘类名.变量名’ 引用
b>类执行顺序：静态代码块》匿名代码块》构造方法，匿名代码块主要用于赋初值
package com.kuangstudy.oop;
c》静态导入包
import static java.lang.Math.random;

public class oopmain {
public static void main(String[] args) {
// System.out.println(Math.random());
System.out.println(random());//静态导入包后
}
}
d>补final修饰的类或方法就不能再补别的对象引用

14》抽象类
package com.kuangstudy.oop;

public abstract class abs {
//约束，有人帮我们实现，类单继承，接口可多继承
//abstract 抽象方法，只有名子没有方法的实现，
//只有用继承的非abstract子类来实现父类的方法
public abstract void dosomething();
/*
a>不能new,只能靠子类来实现它：约束！
b>抽象方法一定存在抽象类中，抽象类中可存在普通方法
*/
15》接口（interface）
接口：只有规范，自已无法写方法~专业的约束 约束与实现的分离; 面向接口编程
a>约速
b>定义一些方法，让不同的人实现
c>方法都是public abstract
d>常量：public static final
f>接口不能补实例化，接口中没有构造方法
g>implements可以实现多个接口
h>必须重写接口中的方法
package com.kuangstudy.oop;
//多继承
public class faceimplements1 implements face,TimeService{
@Override
void add(String name) {
super.add(name);
}
@Override
void delete(String name) {
super.delete(name);
}
@Override
void update(String name) {
super.update(name);
}

@Override
void query(String name) {
    super.query(name);
}
@Override
public void timer() {
}

}
/*
package com.kuangstudy.oop;
public interface face {
//接口中的所有定义都是抽象的public abstract
//接口都需要有实现类;一定义属性就是一个常量
//public static final
int age=99;
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}

package com.kuangstudy.oop;
public interface TimeService {
void timer();
}
*/
16>内部类
a>一个类中只能有一个public类，但可以可以有多个类
b>成员内部类，静态内部类，局部内部类，匿名内部类