0
点赞
收藏
分享

微信扫一扫

JAVA面向对象

小云晓云 2022-02-20 阅读 34

文章目录

1.面向对象基本概念

2.类与对象

什么是类?

3.类和对象的定义格式

注意:类是类别,分类的意思,所以类不是一个具体的事物,类代表一类事物,类的结果规则需要记住.

在JAVA中可以使用以下的语句定义一个类:
class 类名称{
属性名称;
返回值类型 方法名称(){}
}

/**
	2022-2-18
	面向过程,以步骤为单位,U一步一步完成某一个具体事情
	面向对象,以对象为单位,通过调度组合不同的对象来完成某一个事情
	
*/
public class Test26{
	public static void main(String[] args){
		
		Horse h=null;//声明一个类的变量(除了八种基本数据类型以外,都是引用数据类型,包括数组)
		
		//实例化对象,创建一个Horse类型的对象
		h=new Horse();
		//有了对象,我们就可以调用对象的属性和方法
		h.name="赤兔马";
		h.age=13;
		
		h.run();//调用方法那么方法就会被执行
		
		//匿名对象,只能使用一次,用完后,该对象就会被释放
		new Horse().run();
		
		h=null;//把对象释放掉
		//当对象不存在时,调用该对象的属性和方法就会报错(空指针)
		//空指针错误(java.lang.NullPointerException)
		h.run();
	}
}

//自定义一个类(类型)
class Horse{
	//在类中定义属性(特征)
	String name;
	int age;
	public void run(){
		System.out.println("我是"+name+"\n年龄:"+age+"\n能力:日行千里!");
	}
	public void eat(){
		System.out.println("吃的食物:优良的马草!");
	}
}

4.对象内存分析

类与对象小结

5.封装性

封装的好处

模块化
信息隐藏
代码重用
插件化易于调试
具有安全性
封装缺点:
会影响执行效率

成员变量和局部变量

/**
	2022-2-19
	封装性
	
*/
public class Test27{
	public static void main(String[] args){
		
		Person p=new Person();
		p.setName("萌萌");
		System.out.println("名字是:"+p.getName());
		
	}
}

//加上private就是进行封装了
class Person{
	//属性的封装
	private String name;//成员变量,在类中定义
	private int age;//成员变量
	
	//getter和setter
	//对外提供一个可以访问name属性设置和获取name属性的方法
	public void setName(String name){//参数也是局部变量
		this.name=name;
	}
	public String getName(){
		return this.name;
	}
	
	public void setAge(int age){
		this.age=age;
	}
	public int getAge(){
		return this.age;
	}
	
	public void run(int len){
		int i;
		int m=len;//m也是局部变量
		System.out.println("我跑了"+m+"米");
		System.out.println("年龄是"+age);
	}
}

6.构造方法

构造方法小结

7.this关键字

/**
	2022-2-19
	构造方法
*/
public class Test28{
	public static void main(String[] args){
		
		Dog dog=new Dog();
		Dog dog1=new Dog("汪汪",5);
	}
}


class Dog{
	//声明变量
	private String name;
	private int age;
	
	//构造方法
	public Dog(){
		System.out.println("构造方法执行了");
	}
	public Dog(String name){
		this.name=name;
		System.out.println("带一个参数的构造方法被执行了!");
	}
	public Dog(String name,int age){
		this(name);
		//调用其他构造方法时,此语句需要在第一句,在构造方法相互调用时必须要有出口
		this.age=age;
		System.out.println("带两个参数的构造方法被执行了!");
		//this(name);错误,必须先写this
	}
	
	public void setName(String name){
		this.name=name;
	}
	
	public String getName(){
		return this.name;
	}
	
	public void setAge(int age){
		this.age=age;
	}
	
	public int getAge(){
		return this.age;
	}
	
}

8.值传递与引用传递

9.对象的一对一关系

/**
	2022-2-19
	两个对象之间的一对一关系:
	比如:一个英雄对一个兵器
	代码如何表示?
	双向一对一
	单向一对一
*/
public class Test29{
	public static void main(String[] args){
		
		Hero hero=new Hero("刘备",200);
		Weapon weapon=new Weapon("双锤",4);
		
		//把两个对象关联起来
		hero.setWeapon(weapon);
		weapon.setHero(hero);
		
		//通过英雄来获取他的信息
		String name=hero.getName();
		int age=hero.getAge();
		Weapon w=hero.getWeapon();
		System.out.println("我是"+name+",我是"+age+"岁,我的武器是:"+w.getName()+",排行"+w.getGrade()+"级");
		
	}
}

//英雄类
class Hero{
	//声明变量
	private String name;
	private int age;
	private Weapon weapon;
	
	public Hero(){
		
	}
	public Hero(String name,int age){
		this.name=name;
		this.age=age;
	}
	
	public void setName(String name){
		this.name=name;
	}
	
	public String getName(){
		return this.name;
	}
	
	public void setAge(int age){
		this.age=age;
	}
	
	public int getAge(){
		return this.age;
	}
	
	public void setWeapon(Weapon weapon){
		this.weapon=weapon;
	}
	
	public Weapon getWeapon(){
		return weapon;
	}
}


class Weapon{
	private String name;
	private int grade;
	private Hero hero;
	
	public Weapon(){}
	public Weapon(String name,int grade){
		this.name=name;
		this.grade=grade;
	}
	
	public void setName(String name){
		this.name=name;
	}
	
	public String getName(){
		return name;
	}
	
	public void setGrade(int grade){
		this.grade=grade;
	}
	
	public int getGrade(){
		return grade;
	}
	
	public void setHero(Hero hero){
		this.hero=hero;
	}
	
	public Hero getHero(){
		return hero;
	}
}

10.static关键字

static关键字的作用:

static使用总结

/**
	2022-2-19
	静态变量或方法不属于对象,依赖类
	静态变量是全局变量,生命周期从类加载后一直到程序结束
	静态变量只有存一份,在静态方法区存储
	静态变量是本类所有对象共享一份
	建议不要使用对象名去调用静态数据,直接使用类名调用
	static修饰一个方法,那么该方法属于类,不属于对象,直接用类名调用
	静态方法不能访问非静态属性和方法,只能访问静态

*/
public class Test30{
	public static void main(String[] args){
		
		Role liubei=new Role("刘备","蜀国");
		Role yunchang=new Role("云长");
		Role zhangfei=new Role("张飞");
		
		liubei.getInfo();
		yunchang.getInfo();
		zhangfei.getInfo();
		
		System.out.println("--------------------");
		System.out.println(liubei.country);
		System.out.println(yunchang.country);
		System.out.println(zhangfei.country);
		
		System.out.println("--------------------");
		liubei.country="唐朝";
		System.out.println(liubei.country);
		System.out.println(yunchang.country);
		System.out.println(zhangfei.country);
		
	}
}


class Role{
	private String name;
	static String country;//静态全局变量
	
	public Role(){}
	public Role(String name){
		this.name=name;
	}
	public Role(String name,String country){
		this.name=name;
		Role.country=country;
	}
	
	public void setName(String name){
		this.name=name;
	}
	
	public String getName(){
		return name;
	}
	
	//静态方法不能访问非静态的数据
	public static void setCountry(String country){
		Role.country=country;
	}
	
	public void getInfo(){
		System.out.println("我的名字是:"+name+",国家是"+Role.country);
	}
}

声明为static的方法有以下几限制:

什么时候使用static?

11.main方法分析

12.代码块

比如说:

13.单例设计模式

单例设计模式:保证一个类仅有一个实例,并提供一个访问它的全局访问点.

两种实现方式:

饿汉式:在第一次调用getInstance方法时,对象被创建,到程序结束后释放
懒汉式:在类被加载后,对象被创建,到程序结束后释放

/**
	2022-2-20
	
*/
public class Test32{
	public static void main(String[] args){
		
		//Singleton1 s=new Singleton1();错误
		Singleton1 s=Singleton1.getInstance();
		s.print();
		Singleton1 s1=Singleton1.getInstance();
		s1.print();
		System.out.println(s==s1);
		
		Singleton2 s2=Singleton2.getInstance();
		s2.print();
		Singleton2 s3=Singleton2.getInstance();
		s3.print();
		System.out.println(s2==s3);
		
	}
}

//饿汉式:占用内存的时间长,提高效率
class Singleton1{
	
	private Singleton1(){}
	private static Singleton1 s=new Singleton1();
	public static Singleton1 getInstance(){
		return s;
	}
	
	public void print(){
		System.out.println("饿汉式测试方法!");
	}
	
}

//懒汉式:占用内存时间短,效率稍低一点
//生命周期短一点
//在多线程访问时会有安全问题
class Singleton2{
	private Singleton2(){}
	private static Singleton2 s;
	
	public static Singleton2 getInstance(){
		if(s==null){
			s=new Singleton2();
		}
		
		return s;
	}
	
	public void print(){
		System.out.println("懒汉式测试方法!");
	}
	
}

在项目中为什么要使用单例,单例有什么好处?

能不能使用构造方法私有化+静态方法来替代单例?

/**
	2022-2-20
	
*/
public class Test32{
	public static void main(String[] args){
		
		//Singleton1 s=new Singleton1();错误
		Singleton1 s=Singleton1.getInstance();
		s.print();
		Singleton1 s1=Singleton1.getInstance();
		s1.print();
		System.out.println(s==s1);
		
		Singleton2 s2=Singleton2.getInstance();
		s2.print();
		Singleton2 s3=Singleton2.getInstance();
		s3.print();
		System.out.println(s2==s3);
		
	}
}

//使用构造方法私有化,来实现工具类,比如Math
class Tools{
	
	private Tools(){}
	public static void print1(){
		
	}
	public static void print2(){
		
	}
}

//饿汉式:占用内存的时间长,提高效率
class Singleton1{
	
	private Singleton1(){}
	private static Singleton1 s=new Singleton1();
	public static Singleton1 getInstance(){
		return s;
	}
	
	public void print(){
		System.out.println("饿汉式测试方法!");
	}
	
}

//懒汉式:占用内存时间短,效率稍低一点
//生命周期短一点
//在多线程访问时会有安全问题
class Singleton2{
	private Singleton2(){}
	private static Singleton2 s;
	
	public static Singleton2 getInstance(){
		if(s==null){
			s=new Singleton2();
		}
		
		return s;
	}
	
	public void print(){
		System.out.println("懒汉式测试方法!");
	}
	
}

14.对象数组与管理

/**
	2022-2-20
	对象数组管理案例
	动态数组:
	1.数组是一种线性数据结构
	2.数组不适合删除插入等操作,适合添加,查找,遍历
*/
import java.util.Arrays;
public class Test33{
	public static void main(String[] args){
		
		ChickenManger cm=new ChickenManger(5);
		cm.add(new Chicken(1,"小小",10));
		cm.add(new Chicken(2,"小二",9));
		cm.add(new Chicken(3,"小三",8));
		cm.add(new Chicken(4,"小四",7));
		cm.add(new Chicken(5,"小五",6));
		
		cm.add(new Chicken(6,"小六",5));
		System.out.println("现在数组的长度是:"+cm.length());
		
		System.out.println("-------------printAll------------");
		cm.printAll();
		
		System.out.println("------------find----------");
		Chicken c=cm.find(6);
		System.out.println(c.print());
		
		System.out.println("--------------update----------------");
		cm.update(new Chicken(1,"小王八",19));
		cm.printAll();
		
		System.out.println("-------------delete------------------");
		cm.delete(2);
		cm.printAll();
		
		
	}
}

//小鸡管理类
class ChickenManger{
	
	private Chicken[] cs=null;
	private int count=0;//记录当前数组元素的个数(下标)
	
	public ChickenManger(){}
	public ChickenManger(int size){
		if(size>0){
			cs=new Chicken[size];
		}
		else{
			cs=new Chicken[5];
		}
	}
	
	public int length(){
		return cs.length;
	}
	
	//添加,实现动态数组
	public void add(Chicken c){
		if(count>=cs.length){
			//数组已满,需要扩充
			
			//算法一:扩充原来的一半
			int newLen=cs.length*2;
			cs=Arrays.copyOf(cs,newLen);
			
			//算法二:扩充原来的一倍
		}
		cs[count]=c;
		count++;
	}
	//删除
	public void delete(int id){
		
		for(int i=0;i<count;i++){
			if(cs[i].getId()==id){
				//找到了要删除的对象,把该对象之后的对象向前移动一位
				for(int j=i;j<count-1;j++){
					cs[j]=cs[j+1];
				}
				//把最后一个对象赋值为空
				cs[count-1]=null;
				count--;//下标减一
				break;
			}
		}
	}
	//更新
	public void update(Chicken c){
		Chicken temp=find(c.getId());
		if(temp!=null){
			temp.setName(c.getName());
			temp.setAge(c.getAge());
		}
	}
	//查找
	public Chicken find(int id){
		for(int i=0;i<count;i++){
			if(cs[i].getId()==id){
				return cs[i];
			}
		}
		return null;
	}
	//输出所有
	public void printAll(){
		for(int i=0;i<count;i++){
			System.out.println(cs[i].print());
		}
	}
}

//小鸡类(数据对象)value object(vo)
class Chicken{
	
	private int id;
	private String name;
	private int age;
	
	public Chicken(){}
	public Chicken(int id,String name,int age){
		this.id=id;
		this.name=name;
		this.age=age;
	}
	
	public void setId(int id){
		this.id=id;
	}
	public int getId(){
		return id;
	}
	
	public void setName(String name){
		this.name=name;
	}
	public String getName(){
		return name;
	}
	
	public void setAge(int age){
		this.age=age;
	}
	public int getAge(){
		return age;
	}
	
	public String print(){
		return "小鸡ID是"+id+",小鸡的名字是"+name+",月份是"+age;
	}
}
举报

相关推荐

0 条评论