面向对象:以类的方式组织代码,以对象组织数据
特性:
类:抽象概念
对象:具体事物
使用new实例化一个对象,如
Student student = new Student();//实例化对象
new时:
构造器在实例化时首先被自动调用,用于初始化参数。
new的本质是调用了构造器,返回一个对象
名字和类名相同
没有返回类型(不能写!)
可以传参
this是一个指针,指向这个对象本身
public class Person {
String name;
public Person(){
//构造器
this.name = "小明";
}
}
“高耦合,低内聚”,内部数据操作细节自己完成,不由外部干涉, 暴露少部分方法给外部使用。
封装:禁止访问对象的实际表示,而应该通过接口来访问。
修饰词:
public:可以由外部调用,公开使用
private:不可由外部调用
protected:由本包内或不同包的子类调用
使用extend关键字,表示子类是父类的扩展
public class Student extends Person{
Student(String name){
this.name = name;
}
}
使用super可以访问到父类,构造器中super.generator()可以调用父类的构造器。
public class Person {
String name;
public Person(String name){
//构造器
this.name = name;
}
}
public class Student extends Person{
Student(String name){
super(name);
}
}
public class Demo2 {
public static void main(String[] args){
Student s = new Student("小明");
System.out.println(s.name);
}
}
输出“小明”。
如果在子类中不指定调用super,会自动调用
public class Person {
String name;
public Person() {
//构造器
System.out.println("父类Person无参数构造器执行");
}
}
public class Student extends Person{
Student(){
System.out.println("子类Student无参数构造器执行");
}
}
在new Student时输出:
若将子类构造器改为有参,仍然会首先调用父类的无参构造器
大致逻辑如下:
注:
Person类:
public static void test(){
System.out.println("Person Test");
}
Student类:
public static void test(){
System.out.println("Student Test");
}
调用:
public static void main(String[] args){
Student s = new Student("小明");
s.test();
}
结果:
但是,如果修改main
public static void main(String[] args){
Person s = new Student("小明");
s.test();
}
会导致输出:
这可以说明
以上结论来自于静态方法
如果全部改为非静态,即将test改为无static修饰
如
@Override
public void test(){
System.out.println("Student Test");
}
注意点:
同一方法根据对象的不同采用不同的行为
一个对象的实际类型是确定的,但引用类型并不一致
如
Student s = new Student();
Person s1 = new Student();
Object s2 = new Student();
实际类型都是Student,而引用类型可以是其任意父类
对于这样的对象s1/s2,如果没有static修饰,调用一个方法时
若子类父类都有该方法,且子类未重写:调用父类的方法
若都有,但子类重写了:调用子类的方法
若只有子类有,则无法调用(需要强制类型转换修改引用类型)
如在Student写一个新的eat方法:
即能调用的方法取决于其引用类型而不是实际类型
static 属于类,不属于对象,不可重写
final 无法修改,不可重写
private 只属于父类,无法重写
语法:
obj instanceof class
System.out.println(s instanceof Student);//true
System.out.println(s1 instanceof Student);//true
System.out.println(s1 instanceof Object);//true
System.out.println(s2 instanceof Student);//true
System.out.println(s2 instanceof Teacher);//false
如果对象的类是class或class的子类,则为True
在编译状态中,class可以是object对象的父类,自身类,子类。在这三种情况下Java编译时不会报错。(需要在同一条继承链上)
在运行转态中,class可以是object对象的父类,自身类,不能是子类。在前两种情况下result的结果为true,最后一种为false。但是class为子类时编译不会报错。运行结果为false。
编译的时候查看其引用类型判断是否报错。
运行的时候查看其实际类型判断是否为true。
优先级:父类>子类。
子类转父类自动转换。
父类转子类需要强制转换。
转父类后部分方法可能无法再调用。
static修饰(静态)的从属于类,普通的从属于对象
静态方法不能调用非静态成员
无static修饰的变量
每创建一个实例就会生成一个新的内存空间
类内部只有非静态方法可以访问实例变量
静态方法或其他类中只能通过实例对象访问
abstract修饰
abstract修饰的方法
抽象类中可以有抽象方法和具体方法
抽象类无法实例化
抽象方法只声明没有方法体
抽象方法必须在抽象类中
子类重写父类时,必须重写父类的所有抽象方法
不能用private修饰,因为private阻止重写
public abstract class Shape {
public int width; // 几何图形的长
public int height; // 几何图形的宽
public Shape(int width, int height) {
this.width = width;
this.height = height;
}
public abstract double area(); // 定义抽象方法,计算面积
}
public class Square extends Shape {
public Square(int width, int height) {
super(width, height);
}
// 重写父类中的抽象方法,实现计算正方形面积的功能
@Override
public double area() {
return width * height;
}
}
public class Triangle extends Shape {
public Triangle(int width, int height) {
super(width, height);
}
// 重写父类中的抽象方法,实现计算三角形面积的功能
@Override
public double area() {
return 0.5 * width * height;
}
}
普通类:只有具体实现
抽象类:有具体实现和规范(抽象方法)
接口:只有规范,没有具体实现 专业的约束,实现约束和实现的分离,比抽象类更加抽象
[public] interface interface_name [extends interface1_name[, interface2_name,…]] {
// 接口体,其中可以包含定义常量和声明方法
[public] [static] [final] type constant_name = value; // 定义常量
[public] [abstract] returnType method_name(parameter_list); // 声明方法
}
接口只能继承接口
public定义的接口可以被任何类使用,而没有public只能被包内使用
接口中的变量隐式声明为public static final(可以不写),即为常量,所以全部必须初始化
接口中的方法隐式声明为 public abstract
一个类可以实现一个或者多个接口
实现使用implements关键字
<public> class <class_name> [extends superclass_name] [implements interface1_name[, interface2_name…]] {
// 主体
}
与继承类似,可以获得所有的常量和方法
implements在extend后
类实现接口后必须重写所有抽象方法
public interface IMath {
public int sum(); // 完成两个数的相加
public int maxNum(int a,int b); // 获取较大的数
}
public class MathClass implements IMath {
private int num1; // 第 1 个操作数
private int num2; // 第 2 个操作数
public MathClass(int num1,int num2) {
// 构造方法
this.num1 = num1;
this.num2 = num2;
}
// 实现接口中的求和方法
public int sum() {
return num1 + num2;
}
// 实现接口中的获取较大数的方法
public int maxNum(int a,int b) {
if(a >= b) {
return a;
} else {
return b;
}
}
}
类内部定义的类
分类:
内部类还是一个独立的类,会编译为独立的.class文件,但前面会冠以类名和$符号
是内部类的一个成员,可以操作到外部类的私有属性
外部类只有两种级别:public和默认
内部类有四种级别:public、protected、private、默认
Outer o = new Outer();
//外部类可直接new
Inner in = new Inner();
//外部类外需要通过外部类来实例化内部类
Outer.Inner inner = o.new Inner();
没有static修饰,也成为非静态内部类,例:
public class Outer {
class Inner {
// 实例内部类
}
}
static修饰的内部类,例:
public class Outer {
static class Inner {
// 静态内部类
}
}
一个方法中定义的类,如:
public class Test {
public void method() {
class Inner {
// 局部内部类
}
}
}
没有类名的内部类,直接使用new来声明,例:
new <类或接口>() {
// 类的主体
};
一般用法:
继承一个类,重写其方法。
实现一个接口(可以是多个),实现其方法。
public class Out {
void show() {
System.out.println("调用 Out 类的 show() 方法");
}
}
public class TestAnonymousInterClass {
// 在这个方法中构造一个匿名内部类
private void show() {
Out anonyInter = new Out() {
// 获取匿名内部类的实例
void show() {
System.out.println("调用匿名类中的 show() 方法");
}
};
anonyInter.show();
}
public static void main(String[] args) {
TestAnonymousInterClass test = new TestAnonymousInterClass();
test.show();
}
}
和局部内部类相同,可访问外部类所有成员。若位于方法中,只能访问方法中final修饰的量
可以使用非静态代码块进行初始化,在父类的构造函数后执行
手机扫一扫
移动阅读更方便
你可能感兴趣的文章