面向对象编程
什么是面向对象?
以类的方式组织代码,以对象的形式组织(封装)数据。
三大特性
封装
继承
多态
方法调用
1.静态方法
可直接调用(和类一起加载)
2.非静态方法
需要实例化这个类(类实例化之后才存在)
3.引用传递
传递的是一个对象(可见 Hero.java)
public class Person_test {
public static void main(String[] args) {
Person new_person = new Person();
System.out.println(new_person.attack);
Person_test.rename(new_person);
System.out.println(new_person.attack);
}
public static void rename(Person people){
people.attack="章茂淳";
}
}
class Person{
String attack;
}
构造器
一个类即使什么都不写,它也会存在一个方法(无参构造器)
构造器的作用
1.实例化初始值
public class Hero {
public static void main(String[] args) {
Yasuo gamer1 = new Yasuo();
System.out.println(gamer1.Bigname);
System.out.println(gamer1.name);
System.out.println("---------------");
Yasuo gamer2 = new Yasuo("Q",2);
System.out.println("Q技能为"+gamer2.HeroSkills_Q);
}
}
class Yasuo{
String Bigname;
String name;
String HeroSkills_Q;
//显示的定义构造器
//实例化初始值
//1.使用new关键字,本质是在调用构造器
public Yasuo(){
this.Bigname="疾风剑豪";
this.name="亚索";
}
//有参构造:一旦定义了有参构造,无参构造必须显示定义
public Yasuo(String directive,int gamer){
if(directive=="Q"){
HeroSkills_Q="斩钢闪";
System.out.println("玩家"+gamer+"使用英雄:疾风剑豪—亚索,释放了Q技能:斩钢闪");
}
}
//alt+insert idea快捷键生成构造器
}
创建对象内存分析
封装
高内聚,低耦合
高内聚:就是类的内部数据操作细节自己完成,不允许外部干涉;
低耦合:仅暴露少量的方法给外部使用
package com.面向对象编程;
//encapsulation封装
//1.提高程序的安全性,保护数据
//2.隐藏代码的实现细节
//3.统一接口
//4.增加系统可维护性
public class encapsulation {
//属性私有
private String name;
private int age;
private char sex;
//提供一些可以操作这个属性的方法
//提供一些public的get、set方法
public String getName(){
return this.name;
}
public void setName(String name){
this.name=name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if(age>120||age<0){
System.out.println("wrong!");
}
else {
this.age = age;
}
}
}
class test{
public static void main(String[] args) {
encapsulation encapsulation = new encapsulation();
encapsulation.setName("章茂淳");
System.out.println(encapsulation.getName());
encapsulation.setAge(150);
}
}
//alt+insert 生成get/set方法
继承
1.object类
//entends继承
//Hero是父类,extends_hero是子类/派生类
public class extends_hero extends Yasuo{
}
//ctrl+H 快速显示类的继承图
//在Java中,所有的类,都默认直接或者间接继承Object
extends_hero这个类继承了Yasuo
下面是调用示例,自然地子类可以调用父类public的方法,但是private是无法被继承的,可通过get/set获取/修改
public class Object_Test {
public static void main(String[] args) {
extends_hero gamer1 = new extends_hero();
gamer1.attack();
System.out.println(gamer1.Bigname);
}
}
Java中类只有单继承,没有多继承。
一个儿子只用一个爸爸,一个爸爸可以有多个儿子
2.super
super注意点:
1.super调用父类的构造方法,必须在构造方法的第一个,因为先调用父类的构造,再调用子类的方法
2.super必须只能出现在子类的方法或者构造方法中
3.super和this不能同时调用构造方法
supper和this:
1.代表的对象不同
this:本身调用者的这个对象
super:代表父类对象的引用
2.使用前提
this:在本类中使用
supper:只能在有继承条件下才可以使用
3.构造方法
this();本类的构造
super();父类的构造
3.方法重写
public class B {
public static void test(){
System.out.println("B的test");
}
}
public class A extends B{
public void test(){
System.out.println("A的test");
}
}
public class Object_Test {
public static void main(String[] args) {
//方法的调用只和左边,定义的数据类型有关
A a = new A();
a.test();//A
B b = new A();//子类重写了父类的方法
b.test();//B
}
}
重写:需要有继承关系,子类重写父类的方法
1.方法名必须相同
2.参数列表必须相同
3.修饰符:范围可以扩大不能缩小 public>protected>default>private
4.抛出的异常:范围可以被缩小,但不能扩大
public class B {
public void test(){
System.out.println("B的test");
}
}
public class A extends B{
//Override 重写
@Override
public void test() {
System.out.println("A的test");
}
}
public class Object_Test {
public static void main(String[] args) {
//方法的调用只和左边,定义的数据类型有关
A a = new A();
a.test();//A
//父类的引用指向了子类
B b = new A();//子类重写了父类的方法
b.test();//结果也是A
}
}
静态方法和非静态方法差别很大!重写和静态方法没有关系(静态方法和一同加载),重写只和非静态方法有关
为什么需要重写?
父类的功能,子类不满足 Alt+Insert+override
多态
1.多态是方法的多态,属性没有多态
2.有父类和子类之间的关系,才能进行类型转换
3.多态的存在条件:有继承关系,方法需要重写,父类引用指向子类对象
class Person{
String attack;
public void run(){
System.out.println("person");
}
}
public class Student extends Person{
@Override
public void run() {
System.out.println("student");
}
public void eat(){
System.out.println("eat");
}
}
public class Object_Test {
public static void main(String[] args) {
//一个对象的实际类型是确定的
//可以指向的引用类型就不确定了:父类的引用指向子类
//Student 能调用的方法都是自己的或者继承父类的
Student s1 = new Student();
//Person 父类型,可以指向子类,但是不能调用子类独有的类型
Person s2 = new Student();
Object s3 = new Student();
//对象能执行哪些方法,主要看对象左边的类型,和右边关系不大
s2.run();//student 子类重写了父类的方法,执行了子类的方法
s1.run();//student
((Student)s2).eat();//父类中是没有eat方法的,强制转换,高转低
s1.eat();
}
}
instanceof
instanceof是Java中的二元运算符,左边是对象,右边是类;当对象是右边类或子类所创建对象时,返回true;否则,返回false。
public class Object_Test {
public static void main(String[] args) {
Object object = new Student();
//Object > String
//Object > Person > Teacher
//Object > Person > 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
System.out.println("=======================");
Person person = new Student();
System.out.println(person instanceof Student);//true
System.out.println(person instanceof Person);//true
System.out.println(person instanceof Object);//true
System.out.println(person instanceof Teacher);//false
//System.out.println(person instanceof String);//编译报错
System.out.println("=======================");
Student student = new Student();
System.out.println(student instanceof Student);//true
System.out.println(student instanceof Person);//true
System.out.println(student instanceof Object);//true
//System.out.println(student instanceof Teacher);//编译报错
//System.out.println(student instanceof String);//编译报错
//System.out.println(X instanceof Y);
// X 和 Y 存在父子关系,则能够编译通过
// X指向的类型(即new出来右边的那个)和 Y 有父子关系,则instanceof的结果是true,反之则为false
}
}
类型强制转换
1.父类引用指向子类的对象
2.把子类转换为父类,向上转型,自动转换,可能丢失自己本来的一些方法
3.把父类转换为子类,向下转型,强制转换
4.方便方法的调用,减少重复的代码
class Person{
public void run(){
System.out.println("person");
}
}
public class Student extends Person{
public void go(){
System.out.println("go");
}
}
public class Object_Test {
public static void main(String[] args) {
//类型之间的转换: 父 子
//高(父) 低(子)
Person student = new Student();
//student.go(),Person里面没有go方法,将student这个对象强制转换成Student类型,我们就可以使用Student类型的方法了。
((Student)student).go();
}
}
static关键字详解
public class Student {
private static int age;
private double score;
public void run(){
}
public static void go(){
}
public static void main(String[] args) {
Student s1 = new Student();
//
System.out.println(Student.age);//静态变量可以通过类名直接调用
//System.out.println(Student.score);//非静态的变量不可以用类名调用
System.out.println(s1.score);//实例化一个对象 s1 则都可以访问
System.out.println(s1.age);
//也可用类名直接调用静态方法
Student.go();
//Student.run;
go();
//run();
}
}
执行顺序
public class Teacher {
//匿名代码块可赋初值
{
System.out.println("匿名代码块");
}
//静态代码块只执行一次
static{
System.out.println("静态代码块");
}
public Teacher(){
System.out.println("构造方法");
}
public static void main(String[] args) {
new Teacher();
System.out.println("==============");
new Teacher();
}
}
//ouput:
//静态代码块
//匿名代码块
//构造方法
//==============
//匿名代码块
//构造方法
static静态导入包
//还可用于静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Object_Test {
public static void main(String[] args) {
System.out.println(random());
System.out.println(PI);
}
}
被final修饰的类无法被继承!!!
抽象类abstract
1.不能new这个abstract的抽象类,只能靠子类去实现它
2.抽象类中可以写普通的方法
3.抽象的方法必须在抽象类中
//abstract 抽象类 Java类都是单继承的 (接口可以多继承!)
public abstract class action {
//abstract,抽象方法,只有方法名字,没有方法的实现
public abstract void doSomething();
}
public class action_son extends action{
@Override
public void doSomething() {
}
}
接口
声明类的关键字是class,声明接口的关键字是interface
public interface UserService {
//常量都是public static final
int age=99;
//接口中的所有定义其实都是抽象的 public abstract
void run(String name);
void delete(String name);
void update(String name);
void query(String name);
}
public interface TimeServer {
void timer();
}
//类通过 implements 实现接口
//实现了接口的类,就需要重写接口中的方法
//多继承-利用接口实现多继承
public class UserServiceImpl implements UserService,TimeServer{
@Override
public void run(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
@Override
public void timer() {
}
}
接口不能被实例化,接口中没有构造方法
内部类
class嵌套
public class Outer {
private int id=10;
public void out(){
System.out.println("这是外部类的方法!");
}
class Inner{
public void in(){
System.out.println("内部类方法");
}
public void getID(){
System.out.println(id);
}
}
}
public class Object_Test {
public static void main(String[] args) {
Outer outer = new Outer();
//通过这个外部类来实例化内部类
Outer.Inner inner = outer.new Inner();
inner.getID();
}
}
局部内部类
public class Outer {
public void method(){
class Inner{
public void in(){
}
}
}
}
异常机制
Error通常是灾难性的致命性错误
Exception通常是可以被程序处理的
异常处理机制
抛出异常
捕获异常
异常处理五个关键字:
try、catch、finally、throw、throws
public class expect {
public static void main(String[] args) {
int a=1;
int b=0;
try{ //监控区域
System.out.println(a/b);
} catch (Exception e) { //捕获异常,catch里的参数为“想要捕获的异常类型”
System.out.println("Exception");
}catch (Error e){
System.out.println("Error");
}catch(Throwable throwable){
System.out.println("Throwable");
}
finally { //处理善后工作,但是finally不是必须的
System.out.println("finally");
}
}
}
Ctrl+Alt+T //快捷键,添加try/catch或者其它逻辑语句
throw/throws的用法
public class expect {
public static void main(String[] args) {
try {
new expect().test(0);
} catch (ArithmeticException e) {
e.printStackTrace();
}
}
//假设这个方法中,处理不了这个异常,方法上抛出异常
public void test(int a)throws ArithmeticException{
if (a==0) {
throw new ArithmeticException();//1.主动抛出异常,一般在方法中使用
}
}
}
自定义异常
使用自定义异常类的步骤:
1.创建自定义异常类,继承一个异常类
2.在在方法中通过throw关键字抛出异常
3.如果在当前抛出异常的方法中处理异常,可以用try-catch语句捕获处理;否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常,继续进行下一步操作
4.在出现异常方法的调用者中捕获并处理异常
//自定义的异常类
public class MyException extends Exception{
//传递数字>10
private int detail;
public MyException(int a){
this.detail=a;
}
@Override
public String toString() {
return "MyException{" +
"detail=" + detail +
'}';
}
}
public class Exception_Test {
//可能会存在异常的方法
static void test(int a) throws MyException {
System.out.println("传递的参数为:"+a);
if(a>10){
throw new MyException(a);
}
System.out.println("OK");
}
public static void main(String[] args) {
try {
test(11);
} catch (MyException e) {
System.out.println("MyException"+e);
}
}
}
注意:
1.在多重catch块后面,可以加一个catch(Exception)来处理可能会被遗漏的异常
2.在catch中增加一些处理异常的代码
3.尽量添加finally语句块去释放占用的资源