类与对象

最新推荐文章于 2023-07-11 10:20:40 发布

zhangludcsdn

最新推荐文章于 2023-07-11 10:20:40 发布

阅读量289

点赞数

本文链接：https://blog.csdn.net/zhangludcsdn/article/details/77861955

版权

一、ciass Person{

private int a=0;

private String b=null;

public static void main(String args){

Person per=null;

per=new Person();

}

Person per=null;开辟了一个Per的栈空间，a和b开辟了堆空间

per=new Peson()实例化per对象，指堆空间。

二、面对对象

封装性、继承性、多态性。多态为方法的重载

三递归调用

从100+99：98+。。。1

import java.util.Scanner;
public class Operation
{
	public static void main(String args[]){
	System.out.println(addNum(100));
	}
	public static  int addNum(int num){
		if(num==1){
			return 1;
		}
		else{
			return num+addNum(num-1);
		}
	}
	
}

四、为什么会有get，set方法

因为将类内的属性变为私有，进行封装。其他要要访问该属性就得在私有属性下面写get,set方法，其他类调用这些方法来访问该属性。

五、引用传递

import java.util.Scanner;
class Ref{
	String temp="hello";
}
public class Operation
{
	public static void main(String args[]){
		Ref r=new Ref();
		// r.temp="jike";
		tell(r);
		System.out.println(r.temp);
	}
	public static void tell(Ref r){
		r.temp="jike";
	}
	
}

要想改变Ref里面的temp字符串，就必须为TEMP开辟一个堆空间r.temp;

import java.util.Scanner;
class Ref{
	String temp="hello";
}
public class Operation
{
	public static void main(String args[]){
		Ref r=new Ref();
		 tell(r.temp);
		System.out.println(r.temp);
	}
	public static void tell(String temp){
		temp="jike";
	}
	
}

像上面这样写temp始终是hello;

六继承

1.子类对象实例化，必须先调用父类的构造方法，之后调用子类的。

import java.util.Scanner;
class Father{
	public Father(){
		System.out.println("父类构造方法");
	}
}
class Sun extends Father{
	public Sun(){
		System.out.println("子类构造方法");
	}
}
public class Operation
{
	public static void main(String args[]){
		Sun fa=new Sun();
	}
	
}

2.要调用父类的方法必须super();

import java.util.Scanner;
class Father{
	public void tell(){
		System.out.println("父类方法");
	}
}
class Sun extends Father{
	public void tell(){
		System.out.println("重写父类方法");
	}
}
public class Operation
{
	public static void main(String args[]){
		Sun fa=new Sun();
		fa.tell();
	}
	
}

以上子类无法调用父类方法。

import java.util.Scanner;
class Father{
	public void tell(){
		System.out.println("父类方法");
	}
}
class Sun extends Father{
	public void tell(){
		super.tell();
		System.out.println("重写父类方法");
	}
}
public class Operation
{
	public static void main(String args[]){
		Sun fa=new Sun();
		fa.tell();
	}
	
}

以上可以

3.子类重写的父类的方法不能有比父类更加严格的作用域,重写是方法名相同，参数也相同，返回值也相同，只是函数体不相同。重载是参数不同，函数体不同，只发生在；类里。重写发生在继承里面。

void print(){}是default。访问权限private<defaulr<public

七关键字

1.final关键字

1）使用final声明的类不能被继承，

2）声明的方法不能被重写，

3）声明的变量变为常量，

2 instanceof:判断一个对象到底是不是一个类的实例

import java.util.Scanner;
class Father{
	public void tell1(){
		System.out.println("父类方法1");
	}
	public void tell2(){
		System.out.println("父类方法2");
	}
}
class Sun extends Father{
	public void tell1(){
		System.out.println("重写父类方法1");
	}
	public void tell3(){
		System.out.println("子类方法2");
	}
}
public class Operation
{
	public static void main(String args[]){
		Father fa=new Father();
		System.out.println(fa instanceof Father);
		System.out.println(fa instanceof Sun);
		Father da=new Sun();
		System.out.println(da instanceof Father);
		System.out.println(da instanceof Sun);
		
	}
	
}

八、接口

interface interfaceName{

全局变量

抽象方法

}

九、多态

1方法的重载和重写

2 对象的多态性，先向上在向下

向上转型：程序自动完成

父类父类对象=子类实例

向下转型：强制类型转换，子类和父类方法都可以调用

子类子类对象=（子类）父类实例

import java.util.Scanner;
class Father{
	public void tell1(){
		System.out.println("父类方法1");
	}
	public void tell2(){
		System.out.println("父类方法2");
	}
}
class Sun extends Father{
	public void tell1(){
		System.out.println("重写父类方法1");
	}
	public void tell3(){
		System.out.println("子类方法2");
	}
}
public class Operation
{
	public static void main(String args[]){
		// 向上转型
		Father fa=new Sun();
		fa.tell1();
		fa.tell2();
		// 向下转型
		/* Father fa=new Sun();
		Sun su=(Sun)fa;
		su.tell1();
		su.tell2();
		su.tell3(); */
	}
	
}

多态性的应用

向上转型

import java.util.Scanner;
class A{
	public void tell(){
		System.out.println("a----tell1");
	}
}
class B extends A{
	public void tell(){
		System.out.println("b---tell2");
	}
}
class C extends A{
	public void tell(){
		System.out.println("c---tell3");
	}
}
public class Operation
{
	public static void main(String args[]){
		say(new B());
	}
	public static  void say(A a){
		a.tell();
	}
	
}

接口的应用

import java.util.Scanner;
interface USB{
	void start();
	void stop();
}
class C{
	public static void work(USB u){
		u.start();
		System.out.println("工作中");
		u.stop();
	}
	
}
class USBDisk implements USB{
	public void start(){
		System.out.println("U盘开始工作");
		
	}
	public void stop(){
		System.out.println("U盘停止工作");
	}
} 
class Pointer implements USB{
	public void start(){
		System.out.println("打印机开始工作");
		
	}
	public void stop(){
		System.out.println("打印机停止工作");
	}
}
public class Operation
{
	public static void main(String args[]){
		C.work(new USBDisk());
		C.work(new Pointer());
		
	}
	
}

十、泛型

1、以下是创建了两个泛型参数的类，大家可以运行了看看实例化泛型类的对象后，是否可以成功显示

class Gen<K,T>{
	private T take;
	private K key;
	public T getTake(){
		return take;
	}
	public void setTake(T take){
		this.take=take;
	}
	public K getKey(){
		return key;
	}
	public void setKey(K key){
		this.key=key;
	}
	
}
public class Operation{
	public static void main(String args[]){
		Gen<String,Integer> g=new Gen<String,Integer>();
		g.setKey("key");
		g.setTake(10);
		System.out.println(g.getKey()+""+g.getTake());
	}
}

2、如果我创建的是一个String的泛型，调用的函数参数又是Object类型，将String类型的对象赋值给OBJECT的对象就不出现转换异常。此时需要用通配符？

class Gen<T>{
	private T take;
	public T getTake(){
		return take;
	}
	public void setTake(T take){
		this.take=take;
	}
	public String toString(){
		return this.getTake().toString();
	}
	
}
public class Operation{
	public static void main(String args[]){
		Gen<String> g=new Gen<String>();
		g.setTake("jikexyueyuan");
		tell(g);
	}
	public static void tell(Gen<Object> i){
		System.out.println(i);
	}
	
}

一下是修改后的

class Gen<T>{
	private T take;
	public T getTake(){
		return take;
	}
	public void setTake(T take){
		this.take=take;
	}
	public String toString(){
		return this.getTake().toString();
	}
	
}
public class Operation{
	public static void main(String args[]){
		Gen<String> g=new Gen<String>();
		g.setTake("jikexyueyuan");
		tell(g);
	}
	public static void tell(Gen<?> i){
		System.out.println(i);
	}
	
}

泛型接口类

interface Mou<T>{
	public void say();
}
class Mons implements Mou<String>{
	private  String info;
	public Mons(String info){
		this.info=info;
	}
	public void setInfo(String s)
	{
		info=s;
	}
	public String getInfo(){
		return info;
	}
	public void say(){
		
	}
}
public class Operation{
	public static void main(String args[]){
		Mons g=new Mons("jikexyueyuan");
		System.out.println(g.getInfo());
	}
	
	
}

繁星函数

class Fun{
	public <T>T test(T t){
		return t;
	}
 }
public class Operation{
	public static void main(String args[]){
		Fun f=new Fun();
		String s=f.test("zhanglu");
		System.out.println(s);
	}
	
	
}

泛型数组

public class Operation{
	public static void main(String args[]){
		String arr[]={"www","jikexueyuan","com"};
		tell(arr);
	}
	public static <T>void tell(T arr[]){
		for(int i=0;i<arr.length;i++){
			System.out.println(arr[i]);
		}
	}
	
}

十一、集合类(查看开发文档）

集合是一个动态数组，不同的是集合里面的对象内容可以恩义扩充,collection的常用子类有List set Queue,下面是list集合的使用，可以添加重复元素，排序方式是放入的顺序.

1 list集合

import java.util.ArrayList;
import java.util.List;
public class Operation{
	public static void main(String args[]){
		List<String> lists=null;
		// lists=new ArrayList<String>();//通过list的实现类实例化list接口类对象。K
		lists=new Vector<String>();
		lists.add("a");
		lists.add("b");
		lists.add("c");
		lists.remove(0);
		for(int i=0;i<lists.size();i++)
		{
			System.out.println(lists.get(i));
		}
		System.out.println(lists);
		System.out.println("集合是否为空:"+lists.isEmpty());
		System.out.println("b是否存在："+lists.indexOf("b"));//返回具体数值的索引，返回整数
	}
	
}

我们发现ArrayList与Vector实现结果是一样的，下面我们看看它们的使用区别

当要考虑线程安全的时候使用Vector,反之使用ArrayList

2 SET接口

ALT+CTRIL+上下箭头表示窗口转动，ctrl+D表示复制当前行在他的右边

Set接口中不可以加入重复元素，但是可以排序，常用的接口子类

1）散列存放：HashSet

2)有序存放：TreeSet

 import java.util.HashSet;
 import java.util.TreeSet;
import java.util.Set;
public class Operation{
	public static void main(String args[]){
		Set<String> Sets=null;
		// Sets=new HashSet<String>();
		Sets=new TreeSet<String>();
		Sets.add("a");
		Sets.add("b");
		Sets.add("c"); 
		Sets.add("d");
		Sets.add("e");
		Sets.add("f"); 
		System.out.println(Sets);
		System.out.println("集合是否为空:"+Sets.isEmpty());
	
	}
	
}

3 Iterator接口

只要是集合我们就要使用Iterator来进行输出。输入了多个对象，一个一个轮流判断，如果是对象就取走，判断下一个对象，不是退出。

4 ,Map 接口

MAP接口与集合有区别，map的保存时以键值对的形式保存，常用的子类有HashMap无序存放，Key不允许重复，Hashtable无序存放，KEY不允许重复.HASHMAP不是线程安全，hashTable是线程安全。HASHMAP允许value为空值，hashtable不允许为空值