JavaOOP(面向对象)学习体会

最新推荐文章于 2022-07-27 15:35:22 发布

qq_39095899

最新推荐文章于 2022-07-27 15:35:22 发布

阅读量191

点赞数 2

分类专栏： JavaSE总结文章标签：面向对象编程抽象类多态类封装

本文链接：https://blog.csdn.net/qq_39095899/article/details/103842219

版权

JavaSE总结专栏收录该内容

16 篇文章 0 订阅

订阅专栏

JavaOOP(面向对象)学习体会

类和对象的概念

类：具体相同特征和行为的事物的抽象
对象：万事万物皆对象
类是对象的类型！
对象是类的实例 !

封装

//特征---->属性(特性)
  String name;
  int age;
  String[] hobbys;

	//行为--->方法(函数)
	public void run() {
		System.out.println("奔跑吧鼠宝宝！");
	}

运行只能在main函数中运行

public class Main {
	public static void main(String[] args) {
	Person person = new Person();//创建对象才能调用类中的方法
		person.run();
	}
}

属性的可见度

public 公开的，任何包中任何类中都可以访问到此属性！不符合封装特性！
protected 受保护的，本类及其子类和同包中可以访问！
private 私有的，仅本类可以访问！(常用写法)

创建一个Girl类如下

public String name;
protected int age;
private String phoneNumber;

注意:属性私有化在外界无法访问！
需要借助setter和getter方法

//存值方法
public void setPhoneNumber(String phone) {
	//注意 此时的phone的是形参！
	phoneNumber = phone;
}
//取值方法
public String getPhoneNumer() {
	return phoneNumber;
}

在Main类中测试

package com.a;
public class Main {
	public static void main(String[] args) {	
		Girl myGirl = new Girl();
		myGirl.name = "Aurora";
		myGirl.age = 18;
		//myGirl.phoneNumber = "12038520107";//传值
		myGirl.setPhoneNumber("12038520107");
		System.out.println(myGirl.getPhoneNumer());
	}
}

setters和getters方法

构造方法(带参构造无参构造)

toString方法，重写的对象的输出方式

必须私有化属性才能写setters和getters方法
alt+shift+s 快捷提示方法

public class Student {
       private int num;
       private String name;
       private String sex;
       private int age;
 	//构造方法----(初始化方法)
       public Student() {
    	   //无参数 构造方法
       }
       //带参构造方法
       public Student(String name, int num, String sex, int age) {
    	   this.name = name;
    	   this.num = num;
    	   this.sex = sex;
    	   this.age = age;
       }       
       //注意:以上两个构造方法 在今后开发中都会补充完整！
	public int getNum() {
		return num;
	}
	public void setNum(int num) {
		this.num = num;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	} 
	@Override
	//重写对象的输出方式  默认输出的是对象在内存中的地址
	public String toString() {
		return  this.num + " " + name + " " + sex + " " + age;
	}
}

在main主函数中测试

public class Main {
	public static void main(String[] args) {
		Student stu1 = new Student();//午餐
		System.out.println(stu1.getName() + " " + stu1.getSex() + " " + stu1.getAge());
		
		Student stu2 = new Student("雯雯", 2, "boy", 18);//有参
		System.out.println(stu2.getName() + " " + stu2.getSex() + " " + stu2.getAge());

		Student stu3 = new Student("超超", 3, "boy", 18);
		System.out.println(stu2);
		System.out.println(stu3);
	}
}

输出结果
this 指代当前调用本方法的对象
this.name 可以理解为对象.name
static 静态关键字
static 修饰的属性和方法由类名直接调用！！！！
super 编译指令，指向父级
final 关键字，修饰类,会阻断继承！修饰方法，方法将不能被重载！

方法的重载(方法名一致，参数不一致)

方法名一致！但是参数不同！

public class Cat {
	public void run() {
		System.out.println("黑猫警长！嘿嘿！");
	}
	public void run(String name) {
		System.out.println(name + "吃肉吗？四块够吗？" );
	}	
	public void run(String name, int count) {
		System.out.println(name + count + "块够了够了！xx真好，谢谢xx！嘿嘿");
	}	
}

测试

public class Main {
	public static void main(String[] args) {
	Cat cat = new Cat();
	cat.run("棒槌");
	cat.run();
	cat.run("大棒槌", 8);
	}
}

在这里插入图片描述
创建了一个Mouse类

	private String name;//对象级属性，由对象调用
	//由对象调用
	public void eat() {
		System.out.println(this);//
		System.out.println(name+"小老鼠，偷吃糖！在磨牙！");
	}
	...
	Mouse mouse = new Mouse();
	mouse.eat();

private static String color;//类级属性，由类名直接调用！
//由类名直接调用
public static void  run() {
		//注意注意！！！在静态方法中，不可以使用this
		//因为本方法由类名直接调用，会跳过对象！！
	System.out.println("别跑！让阿凯养了你！");
}
...
Mouse.run();

继承

extends 继承的关键字！！！
public class 本类名 extends 父类名{

}
继承的特点：

继承的单向的
正常的继承一个类只能有一个父类！
子类继承父类的方法和属性
子类可以新增方法和修改父类中继承来方法

创建一个Person类作为父类

public class Person {
    private String name;
    private String sex;
    private int age;
    
    public Person() {
    	
    }
	public Person(String name, String sex, int age) {
		this.name = name;
		this.sex = sex;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", sex=" + sex + ", age=" + age + "]";
	}	
}

创建一个Student类作为子类

public class Student extends Person{
	private int num;
	private double score;
	//但是怎么给属性赋值呢？
	public Student() {
	}
    //在子类中  构造方法的写法  必须重写
	public Student(String name, String sex, int age,int num, double score) {
		super(name, sex, age);
		this.num = num;
		this.score = score;
	}
	//-------------------------------------
	public int getNum() {
		return num;
	}
	public void setNum(int num) {
		this.num = num;
	}
	public double getScore() {
		return score;
	}
	public void setScore(double score) {
		this.score = score;
	}
	@Override
	public String toString() {
		return "Student [num=" + num + ", score=" + score + ",name=" +
	this.getName() + ", sex=" + this.getSex() + ", age=" +
				this.getAge() + "]";
	}	
}

创建一个Main测试类

public class Main {
	public static void main(String[] args) {
		Person p1 = new Person();	
		Student s2 = new Student("王二狗子", "boy", 10, 1, 90);
		System.out.println(s2);
	}
}

多态

编译时多态：一个接口(方法)，多种实现(方法的重载)
运行时多态：父类可以接收子类对象
多态的作用：
屏蔽子类差异化，写出通用的代码
运行时多态的前提是建立在继承的基础之上！

创建一个Bird类

public class Bird {
	public void fly() {
		System.out.println("飞扬的小鸟");
	}
}

创建一个Chicken子类

public class Chicken extends Bird {
	@Override
	public void fly() {
		System.out.println("一只小鸡");		
	}	
}

创建一个Duck子类

public class Duck extends Bird {
	@Override
	public void fly() {
		System.out.println("一只鸭子");
	}	
}

创建一个Goose子类

public class Goose extends Bird {
	@Override
	public void fly() {
		System.out.println("一只会飞的鹅");
	}	
}

创建一个测试类

public class Main {
	public static void main(String[] args) {
		Bird bird=new Bird();
		Goose goose=new Goose();
		Duck duck=new Duck();
		Chicken chicken=new Chicken();
		//方法一
		bird.fly();
		goose.fly();
		duck.fly();
		chicken.fly();
		//方法二
		Bird[] birds= {bird,goose,duck,chicken};
		for(int i=0;i<birds.length;i++) {
			Bird b=birds[i];
			b.fly();
		}
		//foreach  格式
				/* for( 遍历出来的对象 :  要遍历的数组 ){
				 * }
				 */
		for (Bird bird2 : birds) {
			bird2.fly();
		}
	}
}

在这里插入图片描述

接口

接口: 方法的列表!
只需要声明方法,不需要实现!
可以理解为方法清单
接口:把公共的功能和属性组合起来!封装成标准的特定集合
接口中的方法:

默认修饰符public
默认都是抽象方法,只需要声明不需要实现的方法!

接口中的属性:

访问属性的修饰符默认是public
默认是静态属性static
默认带有final 变量值不可再被修改!

一个类只可以继承一个父类!
一个类可以实现多个接口!
一旦实现某个接口,就必须实现接口中的所有方法!

定义一个Runlist接口

public interface RunList {
	public void run();
	public void color();
}

定义第二个接口TwoInterface

public interface TwoInterface {
	public void wheel();
}

定义一个类实现接口

public class Car implements RunList,twoInterface {
	//只要实现了接口 就必须实现方法
	@Override
	public void run() {
		System.out.println("车会跑");
	}
	@Override
	public void color() {
		System.out.println("车有颜色");
	}
	@Override
	public void wheel() {
		System.out.println("4个轮子");	
	}
}

定义一个测试类Main

public class Main {
	public static void main(String[] args) {
		RunList runlist=new Car();
		runlist.run();
		runlist.color();	
		
	}
}

抽象类

abstract关键字
注意: abstract只能修饰类和方法!
特点:

抽象方法必须放在抽象类中
抽象方法省略{}部分,只需要声明方法即可!
抽象类–>被子类继承–>创建对象(其实就是抽象类不可以new 对象)
抽象类中可以有普通方法,也可以有抽象方法
非抽象类继承抽象类时,子类必须重新写抽象类中的抽象方法
定义一个抽象类

public abstract class Player {
	public String name;
	public void sleep() {
		System.out.println("来来来!一起睡觉了");
	}
	//抽象方法
	public abstract void sports();
}

定义一个子类继承父类

public class PingPongPlayer extends Player {
	//子类必须实现父类的抽象方法
	@Override
	public void sports() {
		System.out.println("来来,相互扇一扇");
	}
}

定义第二个子类

public class FoolballPlayer extends Player {
	@Override
	public void sports() {
		System.out.println("相互提一提");
	}
}

定义一个测试类

public class Main {
public static void main(String[] args) {
		//抽象类-->被子类继承-->创建对象(其实就是抽象类不可以new
		Player player=new PingPongPlayer()
		player.name="邓亚萍";
		FoolballPlayer foolballPlayer=new FoolballPlayer();
		foolballPlayer.name="吴磊";
		player.sleep();
		foolballPlayer.sports();
		player.sports();
	}
}

抽象类与普通类的区别:

抽象类不能new对象;但实现它方法的子类可以new对象
抽象类可以写抽象方法,但其普通子类必须实现该方法
如果一个普通类实现了一个抽象接口或者抽象类，那么意味着必须重写抽象方法
普通类中不能有抽象方法
如果一个类中有抽象方法这个类必须定义为抽象类

抽象类与接口的区别与联系

区别:

抽象类要被子类继承，接口要被类实现
接口只能做方法声明，抽象类中可以作方法声明，也可以做方法实现
接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量
接口是设计的结果，抽象类是重构的结果
抽象类和接口都是用来抽象具体对象的，但是接口的抽象级别最高
抽象类可以有具体的方法和属性，接口只能有抽象方法和不可变常量
抽象类主要用来抽象类别，接口主要用来抽象功能

联系:

二者都不能直接new对象
一个类只能继承一个抽象类,可以实现多个接口(也可以说多继承)
但必须记住继承只能有一个m

qq_39095899

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JavaOOP(面向对象)学习体会

JavaOOP(面向对象)学习体会类和对象的概念类：具体相同特征和行为的事物的抽象对象：万事万物皆对象类是对象的类型！对象是类的实例 !封装//特征---->属性(特性) String name; int age; String[] hobbys; //行为--->方法(函数) public void run() { System.out.pri...
复制链接

扫一扫