Java学习之类与多态

类是面向对象编程中最重要的概念,类是Java程序的基本组成要素。

类声明
类声明: 类修饰符 class 类名 extends 父类名 implements 接口名 {…}

类的修饰符主要有:
•abstract(抽象类) 没有实现的方法,也没有构造方法,可以有抽象方法(只定义方法,不实现)。不能用new操作直接生成实例。不能派生之类。
•final(终结类) 不能派生子类,防止盲目继承,提供系统的安全性。保证类功能不变。
•public(公共类) 可在相同包中访问,不同包中的类都通过import引用后访问。

. 类体
{ }中是类体,包括该类的全部变量和方法。
类成员分为实例成员和类成员两种。区别:在类声明时是否用类修饰符static.(如用static修饰类class,则为类成员,否则是实例成员)。

类体格式: 修饰符 类型变量名
修饰符 返回类型 类方法名( 参数列表 ) throws 异常列表 { 方法体 }

类体中 变量 修饰符:
•public, protected, private 变量访问权限
•static 变量是类变量
•final 常量
•transient 暂时性的变量,通知虚拟机该变量不属于永久状态,用于不同对象的存档
•volatile 多个并发线程共享变量

类 方法 修饰符:
•public, protected, private 方法访问权限
•static 类方法
•final 或abstract方法是否可重写
•native 表示可将java代码与其他语言代码集成
•synchronized 表示同步操作,可用来控制并发线程,共享数据访问

构造方法
构造方法特点:
•构造方法名与类名必须相同
•构造方法是给对象赋初值,所以没有返回值,但不用void来声明
•构造方法不能被程序调用,只能通过new自动调用
•构造方法可由编程人员在类中定义,默认时由Java语言自动生成。但它是个空方法,变量
被赋予该数据类型的默认值
•构造方法可以重载实现不同的初始化方法。调用时按参数决定调用哪个方法

与类相关的多态:
多态的概念:

1.首先多态一定要在继承的前提下;
2.通常情况下,我们实例化类对象:

		class Fu{
		}
		class Zi extends Fu{
		}
		class Demo{
			main(){
				Zi zi = new Zi();
				//多态的使用
				Fu fu = new Zi();
			}
		}
		一个父类的引用指向了它的一个子类的对象,这种情况就叫:多态;
*/
class Person
{
	String name;
	int age;
}
class Student extends Person
{

}
class Teacher extends Person
{
}
class Demo 
{
	public static void main(String[] args) 
	{
		//多态:父类的引用指向了子类的对象
		Person p = new Student();
		System.out.println(p.name);

		Person p2 = new Teacher();
		//不可以
	//	Student stu = new Teacher();//编译错误,不兼容的类型;


	}
}

多态访问成员的特点:

1.成员变量:编译看左边(父类,一定要有),运行时看左边(父类,子类覆盖了父类的成员变量时,打印出的就是父类的变量值)
2.成员方法:编译看左边(父类,一定要有),运行时看右边(子类,子类覆盖了父类的成员方法时,调用的是子类的方法);
3.静态方法:编译看左边(父类,一定要有), 运行时看左边(父类的)

简单说:当多态时,要访问的成员父类中必须要有,否则编译错误;
当子类覆盖父类的成员时,只有当访问是被覆盖的方法时,访问的是子类的,其它都是父类的。

class A
{
	int num = 10;
	
	void fun1(){
		System.out.println("fu --> fun1()");
	}
	static void m(){
		System.out.println("fu类的静态方法m()");
	}
}
class B extends A
{
	int num = 30;
	int num2 = 20;
	void fun1(){
		System.out.println("zi 类重写-- > fun1()");
	}
	void fun2(){
		System.out.println("zi --> fun2()");
	}
	static void m(){
		System.out.println("zi类的静态方法m()");
	}
}
class Demo 
{
	public static void main(String[] args) 
	{
		A a = new B();
		System.out.println(a.num);//10
	//	System.out.println(a.num2);//编译错误,父类中没有num2变量
		a.fun1();
	//	a.fun2();//编译错误,父类中没有fun2()方法;

		a.m();
	}
}


请让我轻轻地告诉你多态是多么的方便了程序员们,让他们在后期修改之]前合作编写软件时的益处所在:
首先上个“跑图”的例子,跑图中原本有三个类:Line、Tu、Demo,原本一旦出现新增或路线更改时,我们需要的三个类都同时进行修改,造成人员劳动的重复和浪费。经过引入多态处理的新程序,我们可以发现当路线出现修改任务时,没有造成另外两个类的附带修改,减少不必要的工作量。所以下面我们看看多态的巧妙之处吧!

class MyLine
{
	void show(){
	}
}
class Line1
{
	void show(){
		System.out.println("线路1");
	}
}
class Line2
{
	void show(){
		System.out.println("线路2");
	}
}
class Line3 extends MyLine
{
	void show(){
		System.out.println("线路3");
	}
}
class Tu
{
	/*
	void paoTu(Line1 line){
		line.show();
	}
	*/
	/*
	void paoTu(Line2 line){
		line.show();
	}
	*/
	void paoTu(MyLine line){
		line.show();
	}
}
class Demo 
{
	public static void main(String[] args) 
	{
		/*
		Line1 line = new Line1();
		*/
		/*
		Line2 line = new Line2();
		*/
		/*
		MyLine line = new Line2();
		*/
		MyLine line = new Line3();
		Tu tu = new Tu();
		tu.paoTu(line);
	}
}


转一个学习过程中遇见的漂亮诠释多态各方面细节的案例:儿子装爹。

class  爹{
		int age = 60;
		void teach(){
			System.out.println("讲JavaEE");
		}
	}

	class 儿子 extends 爹{
		int age = 30;
		void teach(){
			System.out.println("讲C++");
		}
		void playGame(){
			System.out.println("打英雄联盟");
		}
	}

	//有一天来人,请老爹讲Java,把老爹请走了。
	//之后又来个人找老爹讲Java,给的报酬还挺高,儿子想代替他爹去。于是,进入换上他爹的衣服,
	//贴上胡子,跟那个人去讲课去了

	main(){
		老爹 kd = new 儿子();//多态
		System.out.println("我今年:" + kd.age);//60
		System.out.println("我给大家讲:" + kd.teach());//C++
	//	System.out.println("休息的时候自己做点自己的事,打游戏:" + kd.playGame());//不能打

		//讲完之后回家,换衣服,洗脸,返回到儿子原样
		儿子 kz = (儿子)kd;
		kz.playGame();
	}
*/
class 老爹{
		int age = 60;
		void teach(){
			System.out.println("讲JavaEE");
		}
	}

	class 儿子 extends 老爹{
		int age = 30;
		void teach(){
			System.out.println("讲C++");
			
		}
		void playGame(){
			System.out.println("打英雄联盟");
		}
	}
class Demo 
{
	public static void main(String[] args) 
	{
		老爹 kd = new 儿子();//多态
		System.out.println("我今年:" + kd.age);//60
		System.out.println("我给大家讲:" + );
		kd.teach();//C++
	//	System.out.println("休息的时候自己做点自己的事,打游戏:" + kd.playGame());//不能打

		//讲完之后回家,换衣服,洗脸,返回到儿子原样
		儿子 kz = (儿子)kd;
		kz.playGame();
	}
}


String类的操作:
java.lang.String类:

1.String 类代表字符串。Java 程序中的所有字符串字面值(如 “abc” )都作为此类的实例实现。
2.字符串是常量;它们的值在创建之后不能更改。
3.获取一个String对象,可以通过字面常量赋值,也可以通过new关键字调用String的构造函数;
String str = “abc”;//OK的
String str2 = new String(“abc”);//OK;

4.构造函数:
1).String(): 初始化一个新创建的 String 对象,使其表示一个空字符序列。
2).String(byte[] bytes) :通过使用平台的默认字符集解码指定的 byte 数组,构造一个新的 String。
3).String(byte[] bytes, int offset, int length):通过使用平台的默认字符集解码指定的 byte 数组,,从offset开始,取length长度;
4).String(char[] value) 分配一个新的 String,使其表示字符数组参数中当前包含的字符序列。
5).String(char[] value, int offset, int count) 分配一个新的 String,它包含取自字符数组参数一个子数组的字符。
6).String(String original):初始化一个新创建的 String 对象,使其表示一个与参数相同的字符序列;换句话说,新创建的字符串是该参数字符串的副本。

public class StringDemo01 {

	public static void main(String[] args) {
		String str = "abc";//隐式的实例化对象;
		str = "bbbb";
		System.out.println(str);
		
		String str1 = new String();
		System.out.println("str1是不是空引用?" + (str1 == null));//false
		System.out.println("字符串长度:" + str1.length());//0
		System.out.println("str1开始" + str1 + "结束");
		
		byte[] byteArray = {97,98,99,100};
		String str2 = new String(byteArray);//将byte数组中的每个值作为Unicode编码,输出编码对应的字符;
		System.out.println("str2的长度:" + str2.length());
		System.out.println("str2 = " + str2);
		
		//String(byte[] bytes, int offset, int length)
		String str3 = new String(byteArray,0,2);
	//	String str3 = new String(byteArray,0,5);//java.lang.StringIndexOutOfBoundsException
		System.out.println("str3 = " + str3);
		
		//String(char[] value)
		char[] charArray = {'x','y','z'};
		String str4 = new String(charArray);
		System.out.println("str4 = " + str4);
		
		//String(char[] value, int offset, int count)
		String str5 = new String(charArray,1,2);
		System.out.println("str5 = " + str5);//yz
		
		//String(String original)
		String str6 = new String("abcd");
		System.out.println("str6 = " + str6);		
	}

}

String的特点:

字符串是常量;它们的值在创建之后不能更改。

比较的就是两个字符串对象中存储的字符序列是否完全相同

public class StringDemo3 {

	public static void main(String[] args) {
		String str1 = "hello";
		str1 += "world";
		System.out.println("str1 = " + str1);//helloworld;
		
		String str2 = "hello";
		String str3 = "hello";
		System.out.println("str2 == str3 : " + (str2 == str3));//true
		System.out.println("str2.equals(str3) : " + str2.equals(str3));//true
		
		String str4 = new String("hello");
		String str5 = new String("hello");
		System.out.println("str4 == str5 : " + (str4 == str5));//false
		//String类重写了equals方法,否则equals方法默认是比较的两个对象的地址;
		//重写后,比较的就是两个字符串对象中存储的字符序列是否完全相同;
		System.out.println("str4.equals(str5) : " + str4.equals(str5));//true
		
		String str6 = new String("hello");
		String str7 = "hello";
		System.out.println("str6 == str7 : " + (str6 == str7));//false
		System.out.println("str6.equals(str7) : " + str6.equals(str7));//true
		
		String str8 = "hello";
		String str9 = "world";
		String str10 = "helloworld";
		String str11 = "hello" + "world"; //String str11 = "helloworld";
		String str12 = str8 + str9;
		String str13 = str8 + "world";
		String str14 = "hello" + str9;
		
		System.out.println("str10 == str11 : " + (str10 == str11));//true
		System.out.println("str11 == str12 : " + (str11 == str12));//false
		System.out.println("str11 == str13 : " + (str11 == str13));//false
		System.out.println("str11 == str14 : " + (str11 == str14));//false
	/*	
		byte b1 = 10;
		byte b2 = 20;
		byte b3 = 10 + 20;//OK的,常量相加
		byte b4 = b1 + b2;//编译错误
		byte b5 = b1 + 20;//编译错误
		byte b6 = 10 + b2;//编译错误
	*/
	}
}

经常用得到的其他一些String类的操作:

替换功能
String replace(char old,char new):将字符串中的old字符替换为new字符
String replace(String old,String new)

去除字符串两空格
String trim():去除字符串两边的空格

按字典顺序比较两个字符串
int compareTo(String str)
int compareToIgnoreCase(String str)

public class Demo {
	public static void main(String[] args) {
		String str = "helloworld";
		//String replace(char old,char new)
		System.out.println("将\"helloworld\"中的l替换为L: " + str.replace('l', 'L'));
		System.out.println("替换后的原字符串:" + str);
		System.out.println("将:" + str + " 中的ll替换为LL: " + str.replace("ll", "LL"));
		System.out.println("替换后的原字符串:" + str);
		//String trim()
		String loginName = "admin";
		String uName = " admin    ";
		System.out.println("\"" + loginName + "\".equals(\"" 
							+ uName + "\") : " + loginName.equals(uName));
		System.out.println("将:\"" + uName + "\"去除两边空格:" + (uName = uName.trim()));
		System.out.println("\"" + loginName + "\".equals(\"" 
				+ uName + "\") : " + loginName.equals(uName));
		
		//int compareTo(String str)
		String str1 = "a";//97
		String str2 = "b";//98
		String str3 = "a";//97
		String str4 = "c";//99
		String str5 = "A";//65
		String str6 = "ac";
		String str7 = "ab";
		
		System.out.println("\"b\".compareTo(\"a\") : " + str2.compareTo(str1));//98 - 97
		System.out.println("\"a\".compareTo(\"b\") : " + str1.compareTo(str2));//97 - 98
		System.out.println("\"a\".compareTo(\"a\") : " + str1.compareTo(str3));//97 - 97
		System.out.println("\"c\".compareTo(\"a\") : " + str4.compareTo(str1));//99 - 97
		System.out.println("\"a\".compareTo(\"c\") : " + str1.compareTo(str4));//97 - 99
		System.out.println("\"a\".compareTo(\"A\") : " + str1.compareTo(str4));//97 - 65
		System.out.println("\"ac\".compareTo(\"ab\") : " + str6.compareTo(str7));
		
		//int compareToIgnoreCase(String str)
		String str8 = "a";
		String str9 = "A";
		System.out.println("\"a\".compareToIgnoreCase(\"A\") : " + str8.compareToIgnoreCase(str9));
		
	}

}

示例:将数组转换为字符串输出;

把数组中的数据按照指定个格式拼接成一个字符串
举例:int[] arr = {1,2,3}; 输出结果:[1, 2, 3]

public class Demo {
	public static void main(String[] args) {
		int[] arr = {1,2,3};
		String str = "[";
		for(int i = 0 ;i < arr.length ; i++){
			str += arr[i];
			if(i != arr.length - 1){
				str += ",";
			}
		}
		str += "]";
		
		System.out.println(str);
	}
}

CharArray:
将所输入的字符串进行反转
举例:键盘录入”abc” 输出结果:”cba”


import java.util.Scanner;

public class Demo {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.print("请输入字符串:");
		String str = sc.next();
		//准备一个新的字符数组,存储字符串中的字符;
		char[] newCharArray = new char[str.length()];
		int newCharIndex = 0;
		//反向的遍历字符串
		for(int i = str.length() - 1 ; i >= 0 ; i--){
			char c = str.charAt(i);
			newCharArray[newCharIndex++] = c;
		}
		//遍历之后,新数组中就是一个反转后的。将字符数组转换为字符串;
		String newString = new String(newCharArray);
		System.out.println("反转后的字符串为:" + newString);	
	}
}



  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值