——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-
类是面向对象编程中最重要的概念，类是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);
}
}
——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-