java面对对象学习笔记

最新推荐文章于 2022-07-23 11:04:28 发布

谷雨白

最新推荐文章于 2022-07-23 11:04:28 发布

阅读量249

点赞数 1

分类专栏：笔记文章标签： java 多态面向对象编程

本文链接：https://blog.csdn.net/weixin_45739665/article/details/107287251

版权

笔记专栏收录该内容

32 篇文章 3 订阅

订阅专栏

java面对对象学习笔记

菜鸡萌新笔记自用，有错误的地方还望大佬指出，感激不尽
多为整理，侵删

1.继承

class 父类{}
class 子类 extends 父类{}
意义：如果子类中有一些重复分方法就不用定义了
extends 关键字：称为扩展，子类有时候也被成为派生类

2.继承的限制

单继承：一个孩子只能有一个亲爸，一个孩子不能有两个亲爸，一个子类只能继承一个父类，不能继承两个父类

错误一个子类继承了2个父类
【错误：一个子类继承了两个父类】

可以多层继承：父传子，子传孙

父传子，子传孙
【正确】

3.访问限制

Private 类型利用get方法访问

4.子类实例化对象

*先调用父类构造方法，再调用子类构造方法（先有老子，才有孩子），实际上子类方法的构造方法中隐含了super()

5.方法覆写

*在Java中访问权限一共有四种

private 最小的访问权限
default 什么都不声明：String name
public 最大的访问权限

*private < default < public

这里覆写了print()方法

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();
}
}

谷雨白

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
java面对对象学习笔记

java面对对象学习笔记菜鸡萌新笔记自用，有错误的地方还望大佬指出，感激不尽多为整理，侵删1.继承class 父类{}class 子类 extends 父类{}意义：如果子类中有一些重复分方法就不用定义了extends 关键字：称为扩展，子类有时候也被成为派生类2.继承的限制单继承：一个孩子只能有一个亲爸，一个孩子不能有两个亲爸，一个子类只能继承一个父类，不能继承两个父类【错误：一个子类继承了两个父类】可以多层继承：父传子，子传孙【正确】3.访问限制Priv
复制链接

扫一扫

专栏目录