面向对象
**面向对象编程的本质就是:**以类的方式组织代码,以对象的组织(封装)数据。
三大特征:封装,继承,多态
从认识论角度考虑是先有对象后有类。对象,是具体的事物。类,是抽象的,是对对象的抽象
从代码运行角度考虑是先有类后有对象。类是对象的模板。
方法的调用
引用传递
//引用传递:对象,本质还是值传递
public class Dome1 {
public static void main(String[] args) {
Perosn perosn = new Perosn();
System.out.println(perosn.name);
change(perosn);
System.out.println(perosn.name);
}
public static void change(Perosn perosn){
perosn.name="dj";
}
}
class Perosn{
String name;
}
创建与初始化对象
使用new关键字:使用new关键字创建的时候,除了分配内存空间之外,还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
构造方法:类中的构造器也称为构造方法,是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点:
1.必须和类的名字相同;
2.必须没有返回类型,也不能写void;
public class Perosn {
//一个类型即使什么都不写,它也会存在一个构造方法(默认)
String name;
//实例化初始值
//使用new关键字,本质是在调用构造器
//快捷键:alt+insert
public Perosn() {
this.name = "xdkj";
}
//有参构造:一旦定义有参构造,无参构造必须定义
public Perosn(String name){
this.name=name;
}
}
封装、继承和多态
*分装
我们程序设计要追求“高内聚,低耦合”。高内聚就是类的内部数据操作细节自己完成,不允许外干涉;**低耦合:**仅暴露少量的方法给外部使用。
快速生成属性个get和set:alt+insert+Getter and Setter
*继承
本质:对某一批类的抽象。所有的类都继承object,私有的无法被继承
extands的意思是“扩展”。子类是父类的扩展
A类 extands B类 A继承了B
只有单继承
- 继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。
- 继承关系的俩个类,一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。
- 子类和父类之间,从意义上讲应该具有"is a”的关系.
**查看继承关系:**ctrl+H 在idea
*super
子类调用父类属性和方法:super.父类的属性和方法
注意:
-
调用父类的构造方法,必须在调用子类构造方法前
-
默认先调用父类的无参构造方法再调用子类的无参构造方法。
-
super和this不能同时调用构造方法
-
this调用本身这个对象
-
super代表父类对象的应用,只能在继承后使用
*重写
注意:是方法的重写和属性无关
public class DomePer1 {
public static void test(){
System.out.println("A=>text");
}
}
public class DomeStu1 extends DomePer1 {
public static void test(){
System.out.println("B=>text");
}
}
public class Dome1 {
//静态方法和非静态方法有很大的区别
public static void main(String[] args) {
//静态方法:方法的调用只和左边,定义的数据类型有关
DomeStu1 b=new DomeStu1();
b.test();
//父类的引用指向子类
DomePer1 a=new DomeStu1();
a.test();
}
}
*多态
- 动态编译:类型
- 即同一方法可以根据发送对象的不同而采用多种不同的行为方式。一个对象的实际类型是确定的,但可以指向对象的引用的类型有很多
- 多态存在的条件
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象
- 注意:多态是方法的多态,属性没有多态性。
注意:
- 多态是方法的多态,属性没有多态
- 父类和子类,有联系,类型转换会异常(ClassCasException)
- 存在条件:继承关系,方法需要重写,父类引用指向子类
- 不能重写:
- static 方法,属于类,不属于实例
- final 常量
- private 方法
static
static{
//只执行一次
System.out.println("A=>text");
}
抽象类
- abstract修饰符可以用来修饰方法也可以修饰类,如果修饰方法,那么该方法就是抽象方法;如果修饰类,那么该类就是抽象类。
- 抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类。
- 抽象类,不能使用new关键字来创建对象,它是用来让子类继承的
- 抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。
- 子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法,否则该子类也要声明为抽象类。
//类只能单继承,接口可以多继承
public abstract class A {
//abstract ,抽象方法,只有方法名字,没有方法的实现!
public abstract void Test();
}
//加象类的所有方法,继承了它的子类,都必须要实现它的方法~除非也是abstract
public class B extends A {
@Override
public void Test() {
System.out.println("cxs");
}
}
接口
声明接口的关键字是interface,接口的本质是契约
接口:只有规范!自己无法写方法专业的约束!约束和实现分离:面向接口编程
//接口都要有实现类
public interface UserService {
//常量~public static final
int Age=88;
//接口中的所有定义其实都是抽象的 public abstract
void add(String name);
void delete(String name);
void update(String name);
void select(String name);
}
public interface TimeService {
void timer();
}
//类可以实现接口implements
//实现接口的类,必须重写接口中的方法
//多继承
public class UserServiceImp implements UserService,TimeService {
@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 timer() {
}
}
注意:接口不能实例化,接口中没有构造方法
内部类
内部类就是在一个类的内部在定义一个类,比如,A类中定义一个B类,那么B类相对A类来说就称为内部类,而A类相对B类来说就是外部类了。
-
成员内部类
public class Outer { private int id; public void out(){ System.out.println("这是外部类的方法"); } public class Inner{ public void in(){ System.out.println("这是内部类的方法"); } //访问外部类字段 public void getID() { System.out.println(id); } } } public static void main(String[] args) { Outer outer=new Outer(); //通过这个外部类来实例化内部类 Outer.Inner inner=outer.new Inner(); inner.getID(); }
-
静态内部类
public class Outer { private int id; public void out(){ System.out.println("这是外部类的方法"); } public static class Inner{ public void in(){ System.out.println("这是内部类的方法"); } } }
-
局部内部类
public class Outer { //局部内部类 public void out(){ class Inner{ } } }
-
匿名内部类
public class Appliction { public static void main(String[] args) { //没有名字初始化类 new Inners().eat(); } } class Inners{ public void eat(){ System.out.println("1q"); } }