java面向对象
目录
什么是面向对象
java的核心思想就是OOP，面向对象编程
-
面向过程
就是第一步做什么，第二步做什么。。。
比如出自动门是，开门、出去
-
面向对象
就是分类，我做什么，你做什么
比如出自动门：我：出门 ；门：开
类与对象的创建
package com.yyx;
public class Student {
//定义变量
private int id;
//定义方法,一般是构造方法和get、set方法以及toString方法
//无参构造方法
public Student() {
}
//有参构造方法（可以有多个）
public Student(int id) {
this.id = id;
}
//get方法
public int getId() {
return id;
}
//set方法
public void setId(int id) {
this.id = id;
}
//重写方法,toString方法
@Override
public String toString() {
return "Student{" +
"id=" + id +
'}';
}
}
注意：无参构造器是默认自带的，一旦定义了有参构造方法，就要定义无参构造器才能调用无参构造器
创建对象内存分析
Pet类：
public class Pet {
String name;
int age;
public Pet() {
}
public void shout(){
System.out.println("叫了一声");
}
}
测试类Application：
public class Application {
public static void main(String[] args) {
Pet dog = new Pet();
dog.name = "旺旺";
dog.age = 3;
dog.shout();
System.out.println(dog.age);
System.out.println(dog.name);
System.out.println("================");
Pet cat = new Pet();
}
}
面向对象的三大特性
封装
什么是封装，通俗一点来说就是把类中的某些信息进行隐藏，从而使外部程序不能直接对这些信息进行直接的访问，只能通过类中定义的方法对这些隐藏的信息进行操作和访问。【白嫖资料】
目的：使其他类只能通过操控类中的对象来直接达到目的，不能看到具体的实现和属性，从而提高了程序的安全性和便利性。
一般是私有属性，公有方法
package com.yyx;
public class Student {
//定义变量
private int id;
//定义方法,一般是构造方法和get、set方法以及toString方法
//无参构造方法
public Student() {
}
//有参构造方法（可以有多个）
public Student(int id) {
this.id = id;
}
//get方法
public int getId() {
return id;
}
//set方法
public void setId(int id) {
this.id = id;
}
//重写方法,toString方法
@Override
public String toString() {
return "Student{" +
"id=" + id +
'}';
}
}
继承
-
继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。
比如人，学生，所有人有的功能学生也应该有，学生有的东西，小学学生、大学学生也该有。
这时候就要用extents关键词继承，学生继承人，小学学生和大学学生继承学生（间接继承了人）
-
子类可以重写父类方法，添加新属性和新方法
类实际上是将父类定义的更加的具体化的一种手段。父类表示的范围大，而子类表示的范围小
-
可以继承多个类
-
Java之中只允许多层继承，不允许多重继承，Java存在单继承局限。
也就是A继承B，B继承C，此时A就不可以继承C
-
子类不能直接访问父类的私有成员。
//class 子类 extends 父类 {}
//子类又被称为派生类； 父类又被称为超类（Super Class）。
class Person {
private String name;
private int age;
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}加入Java开发交流君样：484138291一起吹水聊天
public String getName() {
return this.name;
}
public int getAge() {
return this.age;
}
}
class Student extends Person { // Student类继承了Person类
private int id;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
//这个toString不是重写的父类的，这是java中所有类都默认继承的Object类的toString
@Override
public String toString() {
return "Student{" +
"id=" + id +
'}';
}
}
public class TestDemo {
public static void main(String args[]) {
Student stu = new Student(); // 实例化的是子类
stu.setName("张三"); // Person类定义
stu.setAge(20); // Person类定义
System.out.println("姓名：" + stu.getName() + "，年龄：" + stu.getAge());
}
}
super和this关键字
-
如果子类中出现非私有的同名变量，要引用时：
-
访问父类中的同名变量，用
super -
访问子类本类中的变量，用
this
-
-
如果子类重写方法时，要引用父类中的已经定义好的功能时，用super.方法
-
当子类继承父类后，所有的构造函数都会在内部第一行加上隐式的
super()，super()是访问父类中的无参构造函数。 -
但是，当需要指定父类的构造函数来进行初始化时，手动添加super.(“参数”)的形式来访问父类中的构造函数【白嫖资料】
-
如果子类中的构造函数中，需要引用父类中已经定义好的方法，使用super（参数）
-
子类调用父类构造器时，必须要放在子类构造器第一行
public class Student {
//定义变量
private int id;
//定义方法,一般是构造方法和get、set方法以及toString方法
//无参构造方法
public Student() {
}
//有参构造方法
public Student(int id) {
this.id = id;
}
//get方法
public int getId() {
return id;
}
//set方法
public void setId(int id) {
this.id = id;
}
//重写方法,toString方法
@Override
public String toString() {
return "Student{" +
"id=" + id +
'}';
}
}
public class HighStudent extends Student {
加入Java开发交流君样：484138291一起吹水聊天
public HighStudent() {
}
public HighStudent(int id) {
super(id);
}
}
方法重写
**方法重写：**子类继承了父类的方法后，如果发现在需求下，父类的某些方法不太强大，我们就可以在子类中进行重写。
/**
* 宠物自我介绍
*/加入Java开发交流君样：484138291一起吹水聊天
@Override // 注解不报错 说明你写的就是方法重写 (规范：必须要加)
public void showMyself() {
super.showMyself();
System.out.println("我的品种："+breed);
}
方法重写和方法重载的区别：
重写特点：
-
在继承中的子类中，子类继承了父类的方法后，方法名、参数列表都相同。
-
方法的返回值类型不能大于父类（学了多态就理解了）。
-
方法的访问修饰符不能严于父类。也就是范围可以扩大，但不能缩小 (父类是默认的，你写了
private就不行。) -
不能比父类抛出更多的和更大的异常。(学了异常之后就懂了)
重载特点：
-
在同一个类中，方法名相同，参数列表不同（类型、个数、顺序不同…），这种情况就是方法重载。与方法的返回值类型和访问修饰符无关。
**留的疑问：**为什么在父类中方法不强大，子类又写一遍，还不能把父类中的删掉？美其名曰方法重写？
和多态有关。
多态
多态分为两种
-
编译时多态：方法的重载；
-
运行时多态：JAVA运行时系统根据调用该方法的实例的类型来决定选择调用哪个方法则被称为运行时多态。（多态主要也是指运行时多态）；
多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）
多态存在的三个必要条件：
- 要有继承；
- 要有重写；
- 父类引用指向子类对象
public class Application {
public static void main(String[] args) {
HighStudent s1 = new HighStudent();
Student s2 = new HighStudent();
//这时候我们如果我们调用s1.eat()就是调用HighStudent的eat()方法
s1.eat();
//如果我们调用s2.eat()就是调用Student的eat()方法
s2.eat();
//但是，当我们将s2强转为Student类型的时候，我们就可以调用Student的eat()方法了
((Student)s2).eat();
}
}
instanceof和类型转换
//instanceof 的作用是测试它左边的对像是否是它右边的类的实例。
//判断是否存在父子关系
//System.out.println(X instanceof Y);—>能不能编译通过要看X和Y之间有没有父子关系
//Object > String
//Object > Person > Teacher
//Object > Person > Student
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 dp = new Student();
System.out.println(dp instanceof Student); //true
System.out.println(dp instanceof Person); //true
System.out.println(dp instanceof Object); //true
System.out.println(dp instanceof Teacher); //false
//因为两边类型不同不可转换比较，会报错
//System.out.println(dp instanceof String); //编译报错
Student ds = new Student();
System.out.println(ds instanceof Student); //true
System.out.println(ds instanceof Person); //true
System.out.println(ds instanceof Object); //true
//System.out.println(ds instanceof Teacher); //编译报错
//System.out.println(ds instanceof String); //编译报错
//1\. 把子类转换为父类，向上转型；
//2\. 把父类转换为子类，向下转型：强制转换
//类型之间的转换：父 转 子
//高>>>>转>>>>低
Person dp = new Student();
//dp（现在为Person类型）将这个对象转换为Student类型，我们就可以使用Student类型的方法了
Student ds = (Student) dp;
ds.eat(); //强制转换后可以使用eat()方法
//也可写为
((Student) dp).eat();
加入Java开发交流君样：484138291一起吹水聊天
//子类转换为父类：自动转换，可能丢失自己的本来的一些方法
Student ds1 = new Student();
ds1.eat();
Person dp1 = ds1; //自动转换
((Student) dp1).eat();
Static关键字
public class Student {
//定义变量
private static int id;
private String name;
private int age;
public static void main(String[] args) {
Student s1= new Student();
System.out.println(Student.id);//类变量，id是static的所以可以类来调用
System.out.println(Student.name);//这里会报错，因为name属性不是static的，不可以用泪来调用。
System.out.println(s1.name);//下面这两个变量是非静态的可以用实例来调用
System.out.println(s1.age);
}
}
//方法的Static也一样
抽象类
不重要，了解
普通类是一个完善的功能类，可以直接产生实例化对象，并且在普通类中可以包含有构造方法、普通方法、static方法、常量和变量等内容。
那什么叫抽象方法呢？在所有的普通方法上面都会有一个“{}”，这个表示方法体，有方法体的方法一定可以被对象直接使用。而抽象方法，是指没有方法体的方法，同时抽象方法还必须使用关键字abstract做修饰。
而拥有抽象方法的类就是抽象类，抽象类要使用**abstract关键字**声明。
//定义一个抽象类
abstract class A{//定义一个抽象类
public void fun(){//普通方法
System.out.println("存在方法体的方法");
}
public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰
}
抽象类的使用原则如下：
- 抽象方法必须为public或者
protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public； - 抽象类不能直接实例化，需要依靠子类采用向上转型的方式处理；
- 抽象类必须有子类，使用
extends继承，一个子类只能继承一个抽象类； - 子类（如果不是抽象类）则必须覆写抽象类之中的全部抽象方法（如果子类没有实现父类的抽象方法，则必须将子类也定义为为
abstract类。）
接口
关键字interface
接口是对行为的抽象，只写方法，不写具体实现，由子类继承实现。
就比如学生上学，你只写上学，而不写他怎么上学，走着去，跑着去，坐车去的方式不体现。
重写接口中声明的方法时，需要注意以下规则：
- 类在实现接口的方法时，不能抛出强制性异常，只能在接口中，或者继承接口的抽象类中抛出该强制性异常。
- 保持一致的方法名，保持相同或者相兼容的返回值类型。
- 如果实现接口的类是抽象类，那么就没必要实现该接口的方法。
在实现接口的时候，也要注意一些规则：
- 一个类可以同时实现多个接口。
- 一个类只能继承一个类，但是能实现多个接口。
- 一个接口能继承另一个接口，这和类之间的继承比较相似。
//动物接口
interface Animal {
public void eat();
public void travel();
}
//具体的动物，哺乳动物类ManmalInt
public class MammalInt implements Animal{
public void eat(){
System.out.println("Mammal eats");
}
public void travel(){
System.out.println("Mammal travels");
}
public int noOfLegs(){
return 0;
}
public static void main(String args[]){
MammalInt m = new MammalInt();
m.eat();
m.travel();
}
}
内部类
在类中定义的类
包括这四种：
-
成员内部类
成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）
注意：当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员，需要以下面的形式进行访问：
外部类.this.成员变量外部类.this.成员方法class Circle { double radius = 0; public Circle(double radius) { this.radius = radius; } class Draw { //内部类 public void drawSahpe() { System.out.println("drawshape"); System.out.println(radius); //外部类的private成员 System.out.println(count); //外部类的静态成员 } } }在外部类中如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问：
如果要创建成员内部类的对象，前提是必须存在一个外部类的对象
//第一种方式： Outter outter = new Outter(); Outter.Inner inner = outter.new Inner(); //必须通过Outter对象来创建 //第二种方式： Outter.Inner inner1 = outter.getInnerInstance(); -
局部内部类
定义在方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。
注意：局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。
class People{ public People() { } } class Man{ public Man(){ } public People getWoman(){ class Woman extends People{ //局部内部类 int age =0; } return new Woman(); } } -
匿名内部类
用的最多，在编写事件监听的代码时使用匿名内部类不但方便，而且使代码更加容易维护。
一般使用匿名内部类的方法来编写事件监听代码。同样的，匿名内部类也是不能有访问修饰符和static修饰符的。
匿名内部类是唯一一种没有构造器的类。正因为其没有构造器，所以匿名内部类的使用范围非常有限，大部分匿名内部类用于接口回调。匿名内部类在编译的时候由系统自动起名为Outter$1.class。
一般来说，匿名内部类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的实现或是重写。
scan_bt.setOnClickListener( new OnClickListener() { @Override public void onClick(View v) { // TODO Auto-generated method stub } } ); history_bt.setOnClickListener( new OnClickListener() { @Override public void onClick(View v) { // TODO Auto-generated method stub } } ); -
静态内部类
类前加static。静态内部类不需要依赖于外部类，和类的静态成员属性类似，并且它不能使用外部类的非static成员变量或者方法，这点很好理解，因为在没有外部类的对象的情况下，可以创建静态内部类的对象，如果允许访问外部类的非static成员就会产生矛盾，因为外部类的非static成员必须依附于具体的对象。
public class Test { public static void main(String[] args) { Outter.Inner inner = new Outter.Inner(); } } class Outter { public Outter() { } static class Inner { public Inner() { } } }
443
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
