＜2＞第二期哟

沁颖呀

已于 2022-06-20 16:38:32 修改

阅读量99

点赞数 1

文章标签： java 开发语言

于 2022-06-17 17:52:56 首次发布

本文链接：https://blog.csdn.net/weixin_49141056/article/details/125338057

版权

接上一期

2.8、String类（下）

常用方法及基本使用：

1、学习使用jdk api chm文档

推荐使用的是：1.6的中文版块；点击下载

http://www.java1234.com/a/javaziliao/shuji/2013/0506/355.html

2、下载以后打开，在使用时候可以选择搜索（ctrl+f），这个里面会给你显示这个方法的用法。

public class pro22 {
	public static void main(String[] args) {
		String s="sdafaggrvsawad";
		String s1="sfkormfeicmwi";
		String s2="ws";
		String s3="我是大三学生";
		// charAt:返回在字符串中的索引为2的字符，
		System.out.println(s.charAt(2));
		// 解释：indexOf（查询的字符，从那个位置开始）
		System.out.println("查询s的位置，从索引2以后开始为："+s.indexOf("s",2));
		// conpareto比较函数，比较的是他们的Unicode 
		System.out.println(s.compareTo(s2)<s1.compareTo(s1));
		//截取字符串 subString  
		System.out.println(	s3.substring(1, 6));

小练习1：

//   -- 将字符串：abcdefg反转过来输出
public static void main(String[] args){
    String s1="abcdefg";
    String news1=" ";
    for(int i=s1.length()-1;i>=0;i--){
        news1=news1+s1.charAt(i)
    }
    system.out.println(news1);
}
// --把字符串1、3、5‘7、9变为数组
// 使用循环遍历出数组的长度，确定开辟多大的空间
// 然后在循环，把不是数组的值存入到数组中，
public static viod  main(String[] args){
    String S2="1,3,5,7,9";
    int sz=0;
    for(int i=0;i<s2.length();i++){
        if(s2.charAt(i)!=','){
            sz++;
        }
    }
     int news2[]=new int[sz];
    int j=0;
    for(int i=0;i<s2.length();i++){
        if(s2.charAt(i)!=','){
            // 这里需要使用int的包装类的parseInt方法 把字符串转成int类型；
            news2[j]=Integer.parseInt(str.charAt(i)+"");
            j++;
        }
    }
/*
增强for循环
for each 的语句格式：
    for(元素类型t 元素变量x : 遍历对象obj)
        {
            引用了x的java语句;
        } 
*/
    for(int a :news2){
        system.out.print(a)
    }

}

2.9、类的继承（extends）注意点：Java中只支持单继承；私有方法不能继承；

public class pro23_Zoo {
	private String name;//名字
	private int age;//年龄
//  定义一个方法，表明一个状态	
public void say(){
	System.out.println("我是一个动物，我叫"+this.getName()+"我今年"+this.getAge()+"了 ");
}
	public String getName() {return name;}
	public void setName(String name) {this.name = name;}
	public int getAge() {return age;}
	public void setAge(int age) {this.age = age;}
}
//重写父类方法。
// 定义一个类，继承于父类pro23_Zoo
public class pro23_Dog extends pro23_Zoo {
	// 这个通过对象实列化，然后进行调用，
public void say(){
	System.out.println("我是一只狗，我的名字叫"+this.getName()+"，我今年"+this.getAge()+"了，");
}
	public static void main(String[] args) {
		pro23_Dog dog=new pro23_Dog();
		dog.setName("李华");
		dog.setAge(23);
		dog.say();
	}
}

// super 的使用
//定义一个类，继承于父类pro23_Zoo
public class pro23_Dog_1 extends pro23_Zoo {
	//这是子类的无参构造函数
	public pro23_Dog_1(){
		System.out.println("这是子类的无参构造函数");
	}
	// 这是子类的有参构造函数
	public pro23_Dog_1(String name,int age,int number){
// this.name=name;  这种方式无法访问到父类的私有属性和方法，可以通过super方式，访问父类的私有属性和方法
		super(name,age);
		this.number=number;
		System.out.println("这是子类的有参构造函数");
	}
	//重写父类的方法
	public void say(){
		// 调用父类的say方法
		super.say();
		System.out.println("我是一个动物，我叫"+this.getName()+",我今年"+this.getAge()+"了 ,"+"我的联系方式是："+this.number);
	}
    public static void main(String[] args) {
    	pro23_Dog_1 dog_1=new pro23_Dog_1("小花",23,1668555);
    	dog_1.say();	
}	
	}

    1. 在继承类中，子类可以继承父类的索引属性和方法，在子类的实列化对象中可以直接调用，若是父类中私有的属性，或者方法，就需要用到super（）。
    2. 在实列化过程中，先调用的父类的无参构造，在调用子类的无参数构造，最后在存在有参构造时候，再调用子类的有参构造。
    3. 这里还有一点，若是通过构造方法来实列化，需要在构造方法时候传入参数，在实列话的时候，此时若父类的属性或方法为私有，此时需要用到super关键字方法，来调用在父类中的私有属性。
    4. super也可以调用父类的属性，但需要在调用的地方给返回值，在应用中，多数情况，super调用父类中的方法。

2.10、final 关键字，final是终结完结的意思

1.使用 —final---- 修饰的类不能被继承；

// 定义一个A类
public final class A{

}
// 使用B类来机场北final修饰的A类,
public class b extends A{   //此时会报错，the type B cannot subclass the final class A
}

2.使用final 声明的方法，不能被子类覆盖

//创建一个类
public class C {
    public final void action(){
        system.out.print("我是一个好闺蜜");
    }
}
// 在创建一个D类 继承 C 类  
public class D extends C{ 
    //尝试重写父类中action的方法
    public void action(){ // 在编译的时候会报错，cannot override  the final merhod from C 说不能重写父类final方法；
        system.out.print("我是一个渣男");
    }
}

3.使用final声明得到变量不能被修改，

public class C {
    private  int a=2;
    public final void action(){
            a=4;  // 报错 the finalfield C.a cannot be assigened
        system.out.print("我是一个好闺蜜");
    }
}

4.一般final的使用与static一起用，

public class common{
	public static final String china_captial="北京";
}

public class tese{
    public static void main(String[] args){
        system.out.print(common.china_captial) ; //因为是静态的static ，直接类名点上属性调用
    }
}

2.11、抽象类：在java中，含有抽象方法的类称为抽象类，同样不能生成对象；

注意： abstract

1，包含一个抽象方法的类是抽象类；

2，抽象类和抽象方法都要用abstract关键字修饰；

3，抽象方法只需要声明而不需要实现；

4，抽象类必须被子类（假如不是抽象类）必须重写抽象中的全部抽象方法；

5，抽象类不能被实例化；

//抽象类  abstract 抽象类的标志
public abstract class A {
	private String  name;
	private String  zhiye;// 职业

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
// 定义一个方法
	public void say(){
		System.out.println("我是"+this.name+",我是一个"+this.zhiye);
	}
// 定义一个抽象的方法，职业，让子类去具体实现
    //抽象类的标志
public abstract void  zhiye();
}

// 抽象类的子类B
public class B  extends A{
	public void zhiye() {
		System.out.println("职业：B");	
	}
}
// 抽象类的子类C
public class C  extends A{
	public void zhiye() {
		System.out.println("职业：C");
	}
}
// 抽象类的测试类
public class A_test {
	public static void main(String[] args) {
		B b=new B();
		b.zhiye();
		C c=new C();
		c.zhiye();
	}
}

2.12、接口

1.接口定义：一种特殊的“抽象类”，没有普通方法，由全局常量和公共的抽象方法所组成；1.

接口定义用关键字： interface

//定义一个接口：
public interface A{
    // 定义一个全局变量
    public static final String action="北京";
     /**由于接口里的方法都是抽象的，所以abstract可以省略，实际开发一般都是省略的，开发者的习惯；
     * 定义一个抽象方法 abstract可以省略  
     */
    public abstract void a();
    
}
//定义一个接口2：
public interface B{
    // 定义一个全局变量
    public static final String action1="上海";
     /**由于接口里的方法都是抽象的，所以abstract可以省略，实际开发一般都是省略的，开发者的习惯；
     * 定义一个抽象方法 abstract可以省略  
     */
    public abstract void b();
    
}

2.实现接口可以实现一个或者多个接口：实现接口我们用implements关键字,实现多个接口，中间用逗号隔开，并且实现所有抽象方法：

// 测试接口,若需要实现多个接口，则在接口位置逗号相隔；
public class test implements A,B{
    //接口中有抽象类，需要在子类中实现，所以重写父类中的a,b方法
    public void a(){
        system.out.print("我是测试类a 的方法")
    }
     public void b(){
        system.out.print("我是测试类b 的方法")
    }
    public static void main(String[] args){
        test cs=new test();
        cs.a();
        cs.b();
        //因为定义的是静态的常量，可以直接对象调用
        system.out.print(test.action)
        system.out.print(test.action1)
    }
}

3.在需要继承类和实现接口先继承，后实现接口，上代码

public class C{
    public void say(){
        system.out.print("我会说话")
    }
    
}
// 测试接口,若需要实现多个接口，则在接口位置逗号相隔；在需要继承类和实现接口 先继承，后实现接口
public class test extends C implements A,B{
    //接口中有抽象类，需要在子类中实现，所以重写父类中的a,b方法
    public void a(){
        system.out.print("我是测试类a 的方法")
    }
     public void b(){
        system.out.print("我是测试类b 的方法")
    }
    public static void main(String[] args){
        test cs=new test();
        cs.a();
        cs.b();
        cs。say();
        //因为定义的是静态的常量，可以直接对象调用
        system.out.print(test.action);
        system.out.print(test.action1);
    }
}

4.接口的继承接口可以多继承

// 接口的多继承
// 现有A、B两个接口，定义一个D接口来继承AB接口，
public interface A{
    system.out.print("我是A")
        public abstract void a();
}
public interface B{
        public abstract void b();
    system.out.print("我是B")
}

public interface D extends A,B{
    public abstract void d();
     system.out.print("我是D")
}
// 写出一个测试类
// 因为接口D已经继承了A,B接口，所以直接实现D即可
public class Test extends C implements D{
    public void a() {
        System.out.println("a方法");
    }
    public void b() {
        System.out.println("b方法");
    }
    public void d() {
        System.out.println("d方法");
    }
    public static void main(String[] args) {
        Test t=new Test2();
        t.a();
        t.b();
        t.d();
       
    }
}

2.13java对象的多态性

多态性表现：

1.方法的重载和重写

2.可以用父类的引用指向子类的具体实现，还可以随时的更换为其他子类的具体实现

public class Animal {
    public void say(){
        System.out.println("我是一个动物");
    }
}

public class Cat extends Animal{
    public void say(){
        System.out.println("我是一个猫");
    }
}

public class Dog extends Animal{
    public void say(){
        System.out.println("我是一个狗");
    }
}

public class Test {
    public static void main(String[] args) {
        Dog dog=new Dog();
        dog.say();
        
        Cat cat=new Cat();
        cat.say();
    }
}
// 以上就是最传统的子类的继承，对象实列化的过程，
// 多态具体体现测试，父类指向子类的
public class test{
    //传统
    //  Dog dog=new Dog();
     //   dog.say();
    
    // 多态具体实现 父类指向具体引用 
    Animal animal =new Dog();
    animal.say();
    
    // 随时跟换为其他子类
    Animal animal=new Cat();
    animal.say();
    /*
    Animal animal=new Dog(); 就是后面的new Dog() 子类对象 向上  Animail animal 转型  是安全的；
    */
}

// 向下转型  不安全
public class Test {
    public static void main(String[] args) {
        // 父类引用指向Dog子类的具体实现
        Animal animal=new Dog();
        animal.say();
         
        // 向下转型
        Dog dog=(Dog) animal;
        dog.say();
         
        // 向下转型  因为animal指向的是Dog具体实现 所以会报错
        Cat cat=(Cat)animal;
        cat.say();
    }
}
/*报错Exception in thread "main" java.lang.ClassCastException: com.java1234.chap03.sec13.Dog cannot be cast to com.java1234.chap03.sec13.Cat
	at com.java1234.chap03.sec13.Test.main(Test.java:15)*/

在实际开发中，我们常用的是接口，与使用类的方法一样，父类引用指向子类

// 先定义一个父类接口，
public interface People{
    public abstract void say();
}
//两个具体实现类
public class Student implements People{
    public void say() {
        System.out.println("我是学生");
    }
}
public class Teachert implements People{
    public void say() {
        System.out.println("我是老师");
    }
 
}
//写出一个测试类
public class test{
    People p1=new Student();
    p1.say();
    
    p1=new Teachaer();
    p1.say();

}