java学习笔记整理２-面向对象程序设计

最新推荐文章于 2022-09-29 15:50:25 发布

行者常至，为者常成

最新推荐文章于 2022-09-29 15:50:25 发布

阅读量271

点赞数

分类专栏： JAVA

本文链接：https://blog.csdn.net/qq_39417870/article/details/100079288

版权

JAVA 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

Java是面向对象的语言，先看个简单的程序示例：

class Person {
	String name;
	String getName() {
		return "guangdong "+name;
	}
};
public class Oop {
	public static void main(String args[]) {
		Person p1 = new Person();
		p1.name = "zhangsan";
		Person p2 = new Person();
		p2.name = "lisi";
		
		//输出p1、p2两者的信息，这里通过调用Person类的getName()方法实现，可以很简单的实现信息的添加，而不需要在每个打印函数添加"guangdong"
		System.out.println(p1.getName());
		System.out.println(p2.getName());
	}
}

----------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------
//上面这个程序定义和初始化太麻烦了，可以借助构造函数进行初始化
class Person {
	String name;
	String getName() {
		return "guangdong "+name;
	}

	/* construct function 构造函数 */	
	public Person (String n) {
		name = n;
	}
	
};
public class Oop2 {
	public static void main(String args[]) {
		Person p1 = new Person("zhangsan");//这里初始化就比上个函数简单多了
		Person p2 = new Person("lisi");

		System.out.println(p1.getName());
		System.out.println(p2.getName());
	}
}

类的引入：
java中的类：class定义，创建对象，访问属性和方法
格式如下
class 类名称 {
数据类型属性;
…
public 返回值类型方法名称 (参数1, 参数2, …) {
程序语句;
[return 表达式;]
}
// 构造方法，如果没实现构造方法，编译器自动加上一个无参数的空构造方法
访问权限类名称 (类型1 参数1, 类型2 参数2, …) {
程序语句;
… // 构造方法没有返回值
}
}

this关键字
表示当前对象，当前类

static关键字，参考blog
用来修饰类属性或类方法

代码块
普通代码块：方法的{}就是普通代码块

构造代码块：
class Person {
{
// 构造块
// 每实例化一个对象前，都执行；先于构造方法执行
}
}

静态代码块：
class Person {
static {
// 静态块
// 实例化第一个对象前，执行；只执行一次
}
}

Java三大特性：封装、继承、多态性
封装性–>参考blog
封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。要访问该类的代码和数据，必须通过严格的接口控制。
封装原则：将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其访问。
Java中通过将数据声明为私有的(private)，再提供公共的（public）方法:getXxx()和setXxx()实现对该属性的操作
权限有：
private 本类可以访问
default　本包可以访问
protected　本包和其他包的子类可以访问
public　所有
示例：

class Person {
	private int age;//age被封装起来，只能通过setAge、getAge方法进行访问
	public void setAge(int age) {
		if (age < 0 || age > 200)
			age = 0;
		else {
			this.age = age;
		}
	}
	public int getAge() {
		return age;
	}
}
public class Enc {
	public static void main(String args[]) {
		Person per = new Person();
		//per.age = -1;
		per.setAge(-1);
		System.out.println(per.getAge());
	}
}

继承性：
格式：
class 父类{ }
class 子类 extends 父类 { }

引入：
构造方法
1、如果一个类没有实现构造方法，java编译器会给它定义一个空的构造方法
2、实例化子类对象时，先调用父类的构造方法，再调用子类的构造方法
3、super关键字：子类的构造方法里会默认调用super()；可以在子类构造方法中首行自己调用super()，可加参数；super表示父类，可以用super.xxxx调用父类方法

子类继承父类的属性和方法，也可以覆写

final关键字：final类不能有子类；final方法不能被覆写；final变量变成常量，不能被修改

继承的限制

a–看不到父亲的私房钱：私有属性不能被子类访问
b–看不到父亲的绝招：私有方法不能被子类访问
c–不能把祖传的招式私吞了：子类覆写的方法不能缩小权限

class Father{
	private int money;//Fatherd的私有属性，不能被子类访问
	public int getMoney(){
		
		return money;
	}
	public void setMoney(int money){
		
		 this.money = money;
	}
	public void printInfo(){
		
		System.out.println("This is father!!");
	}

};
class Son extends Father{
	private void printInfo(){//子类覆写的方法不能缩小权限,会报错
		System.out.println("This is son!!");
	}
	
};

public class Ext1{

	public static void main(String args[]){
		Son stu = new Son();
		stu.setMoney(1000);
		stu.printInfo();
		
	}


}

抽象类：
格式
abstract class 类名 {
属性;
普通方法 { }
// 抽象方法
访问权限 abstract 返回值类型方法名 (参数) ; /* 只需要声明，不需要实现 */
}
作用：规定子类必须实现的方法，起“模板”作用
不能实例化对象
子类必须覆写全部抽象方法

接口：
作用：跟抽象类相似，起“模板”作用；子类可以继承多个接口，突破“单继承”的限制
子类必须覆写全部抽象方法

interface A{
	public static int i = 10;
	public abstract int getNum();
}
interface B{
	public static String name = "interface B";
	public abstract String getName();
}

class Son implements  A,B{//子类可以继承多个接口
	public int getNum(){
		return i;
	}
	public String getName(){
		return name;
	}	
	
};

public class Ext3{

	public static void main(String args[]){
		Son stu = new Son();
		System.out.println(stu.getName());
		System.out.println(stu.getNum());
	}


}

多态性
1、方法的重载与覆写
重载overload: 定义多个同名方法，其参数类型、个数不同
覆写override：子类里实现跟父类同样的方法

2、对象的多态性
向上转换
Son son = new Son(); Father f = son;
f.fun(…)只能调用被子类覆写的方法，不能调用只在子类中定义的方法
向下转换
Father f = new Son(); Son son = (Son)f;
在进行对象的向下转换前，必须首先发生对象的向上转换
instanceof: 用来判断一个对象是不是某个类的实例

 class Father{
	private int money;
	public int getMoney(){
		
		return money;
	}
	public void setMoney(int money){
		
		 this.money = money;
	}
	public  void printInfo(){
		
		System.out.println("This is father!!");
	}
	public  void drink(){
		
		System.out.println("drink ...");
	}

};
class Son extends Father{
	public void printInfo(){
		
		System.out.println("This is son!!");
	}
	public void playGame(){
		
		System.out.println("playGame ...");
	}
	
	
};
class Daughter extends Father{
	public void printInfo(){
		
		System.out.println("This is daughter!!");
	}
	public void dance(){
		
		System.out.println("dance ...");
	}
	
};

public class Cnv4{

	public static void main(String args[]){
		Father f = new Father();
		Son s = new Son();
		Daughter d = new Daughter();
		
		playAction(f);
		playAction(s);
		playAction(d);
	}
	public static void playAction(Father f){
		if(f instanceof Son){
			Son son = (Son)f;/*向下转换*/
			son.playGame();
		}else if(f instanceof Daughter){
			Daughter daughter = (Daughter)f;/*向下转换*/
			daughter.dance();
		}else if(f instanceof Father){
			f.drink();
		}
	}

}

异常
在这里插入图片描述
有时程序运行会有些错误造成异常退出，没有完整的执行完，java提供一套异常处理机制。
1、分为Error, Exception两类
Error
JAVA虚拟机本身的问题，跟程序无关，程序不需要处理
Exception
程序本身可以处理的异常
还可以分为
不可查的异常(unchecked exceptions)
RuntimeException及其子类
可查的异常(checked exceptions)
其他异常
还可以分为
运行时异常
RuntimeException及其子类
非运行时异常(编译异常)
其他异常
2、处理原则
对于可查异常必须捕捉、或者声明抛出;
允许忽略不可查的RuntimeException和Error
“运行时异常”都是“不可查异常”
程序中可以捕获处理它，也可以不处理
其他异常在程序中必须处理，否则连编译都过不了
3、处理方法
try…catch…finally
try或catch块中有return或throw语句，
会先执行finally块，再返回来执行return或throw语句
或者再次向上throws
子主题 1
4、throws
写在方法的声明位置，表示如果发生异常，扔给调用者处理
对于“不可查异常”, 系统也会抛出它，写不写throws效果一样
对于“可查异常”，必须处理；处理方法见上
5、throw
人为抛出一个异常
throw“不可查异常”时，可以不处理它
throw“可查异常”时，必须处理；
处理方法见上
6.assert格式

（1）assert [boolean 表达式]

如果[boolean表达式]为true，则程序继续执行。
如果为false，则程序抛出AssertionError，并终止执行。
（2）assert[boolean 表达式 : 错误表达式（日志）]
如果[boolean表达式]为true，则程序继续执行。
如果为false，则程序抛出java.lang.AssertionError，输出[错误信息]。
示例：

public class Div4{

	public static void main(String args[]){
		int m = 0;
		int n = 0;
		int r = 0;		
		try{
			m = Integer.parseInt(args[0]);
			n = Integer.parseInt(args[1]);
			r = div(m,n);
		}catch(ArithmeticException e){//根据不同的异常进行处理ArithmeticException，编译时可以看到具体哪个异常
			System.out.println("main "+e);	
		}catch(NumberFormatException e){
			System.out.println("main "+e);	
		}catch(ArrayIndexOutOfBoundsException e){
			System.out.println("main "+e);	
		}catch(RuntimeException e){
			System.out.println("main "+e);	
		}
		
		System.out.println(m+"/"+n+"="+r);

	}
	
	public static int div(int m,int n) throws ArithmeticException{
		int r = 0;
		try{
			r = m/n;
		}catch(ArithmeticException e){
			System.out.println("div"+e);
			throw e;//抛出异常给调用者
		}
		return r;
	}


}

包及访问权限