java面对对象学习笔记
菜鸡萌新笔记自用,有错误的地方还望大佬指出,感激不尽
多为整理,侵删
1.继承
- class 父类{}
- class 子类 extends 父类{}
- 意义:如果子类中有一些重复分方法就不用定义了
extends 关键字:称为扩展,子类有时候也被成为派生类
2.继承的限制
- 单继承:一个孩子只能有一个亲爸,一个孩子不能有两个亲爸,一个子类只能继承一个父类,不能继承两个父类
【错误:一个子类继承了两个父类】
- 可以多层继承: 父传子,子传孙
【正确】
3.访问限制
- Private 类型利用get方法访问
4.子类实例化对象
*先调用父类构造方法,再调用子类构造方法(先有老子,才有孩子),实际上子类方法的构造方法中隐含了super()
5.方法覆写
*在Java中访问权限一共有四种
-
private 最小的访问权限
-
default 什么都不声明:String name
-
public 最大的访问权限
*private < default < public
6.属性的覆盖
- 属性的覆盖主要就是指的子类种声名了与父类同名的属性;
7.方法的重载与覆写的区别
- 重载 方法名称相同,参数的类型或个数不同,对权限没有要求,而且发生在一个类中
- 覆写 方法名称相同,参数的类型和返回类型全部相同,被覆写的方法不能拥有更严格的权限,而且发生在继承类中
8.super关键字
- supei表示的是从子类调用父类中的指定操作;例如,调用属性,方法,构造等,因为在子类实例化时会默认调用父类中的无参构造,有参数时就要用到super了
*直接访问父类中的方法与属性,而this关键字是先访问本类,当本类中没有时再访问父类 - 案例
class Person {
private String name;
private int age;
public Person(String name,int age)
{
this.setName(name);
this.setAge(age);
System.out.print(“父类中的构造”);
}
public void setName(String name)
{
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return this.name;
}
public int getAge() {
return this.age;
}
public String getInfo() {
return “姓名” + this.getName()+",年纪" + this.getAge() ;
}
}
class Student extends Person{
private String school;
public Student(String name,int age,String school) {
super(name,age);
this.school = school;
System.out.println(“子类student中的构造”);
}
public void setSchool(String school) {
this.school = school;
}
public String getSchool() {
return this.school;
}
public String getInfo() {
return super.getInfo() + “,学校” +this.getSchool();
}
}
public class ExitDemo10{
public static void main(String args[]) {
Student stu = new Student (“张三”,22,“湖北工业大学”);
System.out.println(stu.getInfo());
}
}
9.继承中的排序与倒置案例
class Array{
private int temp[];
private int foot ;
public Array(int len) {
if(len >0) {
this.temp = new int [len];
}else {
this.temp = new int[1];
}
}
public boolean add(int i) {
if(this.foot <this.temp.length) {
this.temp[foot] = i;
foot ++;
return true;
}else {
return false;
}
}
public int[] getArray() {
return this.temp;
}
};
class SortArray extends Array{
public SortArray(int len) {
super(len);
}
public int[] getArray() {
java.util.Arrays.parallelSort(super.getArray());
return super.getArray();
}
};
class ReverseArray extends Array{
public ReverseArray(int len) {
super(len);
}
public int[] getArray() {
int t[] = new int [super.getArray().length];
int count = t.length - 1;
for(int x = 0; x<t.length;x++)
{
t[count] = super.getArray()[x];
count --;
}
return t;
}
};
public class ArrayeDemo01{
public static void main(String args[]) {
SortArray a =null;
a = new SortArray(5);
System.out.print(a.add(23) + “\t”);
System.out.print(a.add(46) + “\t”);
System.out.print(a.add(12) + “\t”);
System.out.print(a.add(76) + “\t”);
System.out.print(a.add(73) + “\t”);
System.out.print(a.add(3) + “\t”);
System.out.print(a.add(87) + “\t”);
print(a.getArray());
}
public static void print(int i[]) {
for(int x= 0 ;x <i.length;x++) {
System.out.print(i[x]+"、");
}
}
}
## 10.Final类
- final声明的类不能被继承,太监类
- final声明的方法不能被子类覆写
- final声明的变量就是常量,而常量不可以修改,而且使用final声明的变量的字母全部采用大写的形*式,所以这也是一个命名要求,即:常量必须全部大写
11.static final关键字
- 使用 static final关键字联合声明的变量成为全局变量
12.抽象类
- 抽象类的概念:包含一个抽象方法的类就称为抽象类,不能直接实例化
- 抽象方法: 只声明而未实现的方法称为抽象方法,抽象方法必须用abstract关键字声明
- 抽象类必须被子类继承,子类(如果不是抽象类)必须覆写抽象类中的全部抽象方法
- 定义格式
abstract class 抽象类名称{
属性;
访问权限 返回值 方法名称 (参数){ //普通方法
【return 返回值】;
}
访问权限 abstract 返回值类型 方法名称(参数); //抽象方法
} - 抽象类中绝对不能使用final
- 抽象类中允许有构造方法,而且完全符合子类对象的实例化过程
13.接口
-
接口是一种特殊的类,里面全部都是由全局变量和公共的抽象方法所组成
-
接口的定义格式
-
interface 接口名称{
全局变量;
抽象方法;
} -
interface A{
public static final String AUTHOR =“李兴华”;
public abstract void print();
public abstract void getInfo();
} -
接口的实现格式
class 子类 implements 接口A,接口B…{
}
接口的使用也必须要使用子类,子类必须覆写抽象方法,implement关键字实现,一个子类可以同时实现多个接口,要覆写接口中的全部方法 -
案列
interface A{
public static final String AUTHOR =“小黑”;
public abstract void print();
public abstract String getInfo();
}
abstract class B{
public abstract void say();
}
class X extends B implements A{
public void say() {
System.out.println(“Hello word”);
}
public String getInfo() {
return "Hello";
}
public void print() {
System.out.println("作者 "+ AUTHOR);
}
}
public class InterfaceDemo02{
public static void main(String args[]) {
X x = new X();
x.say();
x.print();
}
}
- 接口中的方法可以不加abstract 但是抽象类中的方法一定要加abstract
- 接口和抽象类案列2.
interface A{
public static final String AUTHOR =“小黑”;
public abstract void print();
public abstract String getInfo();
}
abstract class B implements A{
public abstract void say();
}
class X extends B {
public void say() {
System.out.println(“Hello word”);
}
public String getInfo() {
return "Hello";
}
public void print() {
System.out.println("作者 "+ AUTHOR);
}
}
public class InterfaceDemo03{
public static void main(String args[]) {
X x = new X();
x.say();
x.print();
}
}
- 接口和抽象类案例4
interface A{
public static final String AUTHOR =“小黑”;
public abstract void print();
public abstract String getInfo();
}
interface B {
public void say();
}
class X implements A,B {
public void say() {
System.out.println(“Hello word”);
}
public String getInfo() {
return "Hello";
}
public void print() {
System.out.println("作者 "+ AUTHOR);
}
}
public class InterfaceDemo04{
public static void main(String args[]) {
X x = new X();
x.say();
x.print();
}
}
- 一个接口虽然不能继承抽象类,但是在java类里面,一个接口可以同时继承多个接口,实现接口的多继承
interface A extends B,C{}{}
14.多态
-
对象转型
对象向上转型: 父类 父类对象 = 子类实例
对象向下转型 : 子类 子类对象 = (子类)父类实例
范例: 对象的向下转型
class A {
public void fun1() {
System.out.println(“A---->public void fun1()”);}
public void fun2() {
this.fun1();}
};
class B extends A{
public void fun1() {
System.out.println(“B ---->public void fun2()”);
}
public void fun3() {
System.out.println(“B---->public void fun3()”);}
};
public class PolDemo05{
public static void main(String[] args) {
A a = new B(); //产生实例,产生向上
B b = (B)a; //产生实例,产生向下
b.fun1();
b.fun2();
b.fun3();
}
要使用向下转型时,一定要向上转型一次
15.instanceof关键字
判断一个对象到底是哪个类的实例
*对象 Instanceof 类 —>返回boolean类型
16.object类
-
提供的equals()方法是比较地址的*
-
接收任意引用类型的对象
-
案例
*class Person{
private String name;
private int age ;
public Person(String name,int age) {
this.name = name;
this.age = age;
}
public boolean equals(Object obj) //覆写Object类中的equals方法
{
if(this == obj) {
return true; //如果两个对象地址相等那么是同一个向量
}if(!(obj instanceof Person )) {
return false;
}
Person per = (Person)obj; //将传递来的对象向下转型,所有的类都继承于object类
if(per.name.equals(this.name)&&per.age==this.age) {
return true;
}else {
return false;
}
}public String toString() { //覆写toString()方法
return “姓名:” + this.name + “;年龄:” + this.age ;
}
};
public class ObjectDemo{
public static void main(String args[]) {
Person per1 = new Person(“小黑”,19);
Person per2 = new Person(“小黑”,19);
System.out.println(per1.equals(per2)?“是同一个人”:“不是同一个人”);
System.out.println(per1.equals(“你好”)?“是同一个人”:“不是同一个人”);
}
}
案例:接收接口实例
interface A{
public String getInfo();
}
class B implements A{
public String getInfo() {
return “Hello word” ;
}
}
public class ObjectDemo02{
public static void main(String args[]) {
A a = new B();
Object obj = a;
A x = (A)obj;
System.out.println(x.getInfo());
}
}
案例3 接受数组实例:
public class ObjectDemo03{
public static void main(String args[]) {
int temp[] = {1,2,3,4,5};
Object obj = temp;
print(obj);
}
public static void print(Object obj) {
if(obj instanceof int []) {
int x[] = (int [])obj;
for(int i = 0; i<x.length; i++)
{
System.out.print(x[i]+"\t");
}
}
}
};
a.整数表示
class Point{
private Object x;
private Object y;
public void setX(Object x) {
this.x = x;
}
public void setY(Object y) {
this.y = y;
}
public Object getX() {
return this.x;
}
public Object getY() {
return this.y;
}
};
public class GenericsDemo01{
public static void main(String main[]) {
Point p = new Point();
p.setX(10); //利用自动装箱炒作: int --->integer --->Object
p.setY(20);
int x = (Integer)p.getX(); //取出数据先变成Integer,之后自动拆箱
int y = (Integer)p.getY();
System.out.println("整数表示,x坐标为 " +x );
System.out.println("整数表示,y坐标为 " +y );
}
}
b.小数表示
class Point{
private Object x;
private Object y;
public void setX(Object x) {
this.x = x;
}
public void setY(Object y) {
this.y = y;
}
public Object getX() {
return this.x;
}
public Object getY() {
return this.y;
}
};
public class GenericsDemo02{
public static void main(String main[]) {
Point p = new Point();
p.setX(10.5); //利用自动装箱炒作: int --->integer --->Object
p.setY(20.6);
float x = (Float)p.getX(); //取出数据先变成Float,之后自动拆箱
float y = (Float)p.getY();
System.out.println("小数数表示,x坐标为 " +x );
System.out.println("小数数表示,y坐标为 " +y );
}
}
c.字符串表示
class Point{
private Object x;
private Object y;
public void setX(Object x) {
this.x = x;
}
public void setY(Object y) {
this.y = y;
}
public Object getX() {
return this.x;
}
public Object getY() {
return this.y;
}
};
public class GenericsDemo03{
public static void main(String main[]) {
Point p = new Point();
p.setX("北纬180度"); //利用自动装箱操作: String --->Object
p.setY("东经150度");
String x = (String)p.getX();
String y = (String)p.getY();
System.out.println("字符串表示,x坐标为 " +x );
System.out.println("字符串表示,y坐标为 " +y );
}
}
17.包装类
*
- 案例 (貌似有点小问题,望大佬告知,感谢)
- public class WrapperDemo01{
public static void main(String[] args) {
int x = 30;
Integer i = new Integer(x); //装箱:把基本数据类型变为包装类
int temp = i.intvalue(); //拆箱:把一个包装类变为基本数据类型
}
}
18.匿名内部类
*接口的实现类只使用一次,可使用匿名内部类
*案例
interface A{
public void printInfo();
}
class X{
public void fun1() {
this.fun2(new A(){ //匿名内部类
public void printInfo() {
System.out.println(“hello word”);
}
});
}
public void fun2(A a) { //接收接口实例
a.printInfo(); //调用接口方法
}
}
public class NoInnerClassDemo02{
public static void main(String args[]) {
new X().fun1();
}
}