记录复习过程中的代码（持续更新）

最新推荐文章于 2024-01-07 14:29:49 发布

RuobaiMEN

最新推荐文章于 2024-01-07 14:29:49 发布

阅读量247

点赞数

分类专栏：基础

本文链接：https://blog.csdn.net/RuobaiMEN/article/details/80059512

版权

基础专栏收录该内容

6 篇文章 0 订阅

订阅专栏

6.3.2，

1，继承的实现

package testDay06_abstract;
/*
 * 计算圆的面积功能
 * 演示父子类之间工作
 */
public class Circle extends Point {

	public static final double PI=3.14;  //常量
	double radius;						//半径
	public double area(){				//圆的面积
		return PI*radius*radius;
	}
	public static void main(String[] args) {
		Circle c = new Circle();  //new出圆对象
		c.setxy(5, 6);	//传入坐标位置	，这是继承的父类的方法
		c.radius=5.5;	//传入圆的半径
		System.out.println("圆心的坐标是：（"+c.x+","+c.y+")");  //调用父类的成员变量
		System.out.println("圆的半径是："+c.radius);
		System.out.println("圆的面积是："+c.area());   
	}
}
class Point{
	int x,y;
	public void setxy(int x, int y){
		this.x=x;
		this.y=y;
	}
}

2，构造方法的继承

this和super

/*
 * this和super关键字的用法！！！
 * 对象new之后，它会自动的，先调用父类的无参构造，再调用子类的无参构造
 */
public class Circle2 extends Point {   //继承Point的子类
	double radius;
	public Circle2(){ 				   //无参构造方法
		radius=3.5;
		System.out.println("子类的无参构造this（）调用222");
	}
	public Circle2(double radius){	   //有参构造方法
		this.radius=radius;
		System.out.println("子类的有参构造");
	}
	void test(int a,int b){
		System.out.println("this is son`s fangfa");
		
	}
	public Circle2(int a,int b,double radius){
//		super(a,b);     //super显示调用父类的构造方法,该语句必须是子类构造方法的第一条语句
		this();		//就是调用自己的无参构造方法，和super()一个道理。！！！！！！！！！！！
	//	this.x=a;	//用this.的方法和上面的super（）实现的功能是一样的
	//	this.y=b;	//用this.的方法和上面的super（）实现的功能是一样的
		this.test(1,2);	//按就近原则，这里调用的是子类的test方法
		super.test();	//super调用的是父类的方法
		this.radius=radius;    //在子类中使用this关键字点出来的东西按照一个就近原则的标准
		//如果子类父类都有，那this.遵循就近原则，使用子类
		//如果子类有，那this. 的就是子类的，如果子类没有而父类有，this.的就是父类的
		System.out.println("子类的全参构造this（）调用333");
	}
	public static void main(String[] args) {
//		Circle2 co = new Circle2();		
//		System.out.println("无参构造的对象：");
//		System.out.println("圆心是：（"+co.x+","+co.y+")半径是："+co.radius);
//		Circle2 ct = new Circle2(4.5);
//		System.out.println("带1个参数构造的对象：");
//		System.out.println("圆心是：（"+ct.x+","+ct.y+")半径是："+ct.radius);
		Circle2 cr = new Circle2(7,8,5.5);
		System.out.println("带2个参数构造的对象：");
		System.out.println("圆心是：（"+cr.x+","+cr.y+")半径是："+cr.radius);
	}
}
class Point{		//父类
	int x,y;
//	double radius;
	public Point(){	//构造方法1
		x=9;
		y=10;
		System.out.println("父类的this（）111");
	}
	public Point(int x,int y){	//构造方法2
		this.x=x;
		this.y=y;
	}
	void test(){
		System.out.println("这是父类的方法");
	}
}

6.3.3，单重继承

一个类只能有一个直接的父类，不能一次性的继承多个类。（想实现多继承用接口）

/*
 * 演示继承传值关系
 * 点，圆，圆柱 三者是依次继承关系
 */
class Point1{							//父父类
	int x,y;
	public Point1(int x,int b){					   //6，父父类接收传过来的2个值
		this.x=x;	//this调用自己的成员变量		   //7，将接收的值赋值给自己的成员变量
		this.y=y;   //this调用自己的成员变量
	}
}
class Circle1 extends Point1{			//父类
	public static final double PI=3.14159;
	double radius;
	public Circle1(int a,int b,double r){           //4，父类接收传过来的3个值
		super(a,b);									//5，将其中的2个值传给父父类
		radius=r;             //5.1将一个值赋值给自己的成员变量
	}
	public double area(){
		return PI*radius*radius;
	}
}
class Cylinder extends Circle1{			//子类	
	double height;
	public Cylinder(int a,int b,double r, double h){   //2，接收传过来的值
		super(a, b, r);								   //3，将其中的3个值传给父类
		height=r;				//3.1将一个值赋值给自己的成员变量
	}
	public double volume(){
		return PI*radius*radius*height;
	}
}

public class Single_inherit {
	
	public static void main(String[] args) {
		Cylinder cy = new Cylinder(5, 6, 4.5, 8.5);  //1，创建Cylinder的对象，并将4个值传入进去
		System.out.println("圆柱体对象cy");
		System.out.println("底面圆心的坐标是：（"+cy.x+","+cy.y+")");    
		System.out.println("底面圆面积是："+cy.area());    //调用父类方法
		System.out.println("圆柱体体积是："+cy.volume());  //调用父父类方法
	}
}

编程练习题：

public class test02 {
/*
 * 编写程序，从一个给定的字符串中删去某一个给定的字符
 */
		public static void main(String[] args) {
			String str = "asdfasgadsasdfgsdfggfhfgj";
			char c = 'f';
			String newstr="";
			char newc;
			for(int i=0;i<str.length();i++){
				newc=str.charAt(i);
				if(newc!=c){
					newstr+=newc;
				}
			}
			System.out.println("删除后的字符串是："+newstr);
		}
}

public class test04 {
	//求5个正数的平均值，并输出大于其平均值的数
	public static void main(String[] args) {
		double[] a ={8,1,3.8,100.05,8};
		double sum=0;
		for(int i=0;i<a.length;i++){
			sum+=a[i];
		}
		double avg = sum/a.length;
		System.out.println("平均值为"+avg);
		System.out.print("大于平均值的数值有:");
		for(int i=0;i<a.length;i++){
			if(a[i]>avg){
				System.out.print(a[i]);
			}
		}
	}
}

域的隐藏

/*
 * 域的隐藏：
 * 子类重新定义一个与父类继承的成员变量完全相同的变量，成为域的隐藏，
 * 即子类定义了与父类同名的成员变量，就是子类变量对父类变量的隐藏。
 * 在这种情况下，子类拥有了两个相同名字的变量，一个来自父类，一个自定义
 * 当子类执行继承的父类方法时，处理的是父类的变量，当子类执行它自己定义的方法时
 * ，所操作的就是它自定义的变量，把来自父类的变量隐藏了
 * 
 */
class A1{
	int i;
	public A1(){
		i=100;
	}
}

class B1 extends A1{
	int i;
	int j;
	public B1(){
		i=500;
		j=super.i;  //使用super得到父类中的i值，并将它赋值给j保存
		
	}
}

public class Hiddenvar {
	public static void main(String[] args) {
		B1 obj = new B1();
		System.out.println("i="+obj.i+"父类i="+obj.j);    
	}
}

方法的重写：

/*
 * 方法的重写示例
 */
class A{
	int i,j;
	public A(int a,int b){
		i=a;
		j=b;
	}
	public void show(){
		System.out.println("i="+i+",j="+j);
	}
}

class B extends A{
	int k;
	public B(int a,int b,int c){
		super(a,b);
		k=c;
	}
	public void show(){   //子类也有父类的方法，且必须是签名相同，参数列表相同，才会出现重写
		System.out.println("k="+k);
	
	}
}

public class Override {
	
	public static void main(String[] args) {
		B obj = new B(1,2,3);
		obj.show();     //如果子类没有重写父类，那么调用的就是父类的show方法
	}
}

抽象方法的继承

	abstract class CShape{
		public abstract int area(); //抽象方法必须放在抽象类中,这个抽象方法的作用是计算值（面积或体积）
	}

	class Rectangle extends CShape{
		int length,width;
		public Rectangle(int l,int w){
			this.length = l;
			this.width = w;
		}
		public int area() {
			return length*width;
		}
		public void show(){
			System.out.println("矩形面积："+area());
		}
	}
	
	class Cuboid extends Rectangle{
		int height;
		public Cuboid(int l,int w,int h){
			super(l,w);
			height=h;
		}
		public int area(){     //表面积
			return 2*(length*width+length*height+width*height);
		}
		public int volume(){   //体积
			return super.area()*height;
		}
		public void show(){
			System.out.println("长方体的表面积："+area());
			System.out.println("长方体体积:"+volume());
		}
	}
public class Shape {
	public static void main(String[] args) {
		Rectangle r = new Rectangle(6,4);
		r.show();
		Cuboid c = new Cuboid(8,7,5);
		c.show();
	}
}

使用super关键字

/*
 * 使用super关键字示例
 */

class A2{
		int a;
		public A2(){
			a=100;
		}
		public void show(){
			System.out.println("a1="+a);
		}
	}
	class B2 extends A2{
		int a;
		public B2(int i, int j){
			super.a=i;   //将传过来的值赋值给父类的 a，new对象的时候就已经传过去了
			a=j;
		}
		public void show(){
			super.show();		//调用父类的show方法
			System.out.println("a2="+a);
		}
	}
public class SuperDemo {
	public static void main(String[] args) {
		B2 obj = new B2(5,6);
		obj.show();
	}
}

接口的继承和使用

/*
 * 定义并使用接口
 * 声明一个新的接口实际上是定义了一个新的引用数据类型
 * 接口与类的比较
 * 1，接口有点像一个规范、一个协议，是一个抽象的概念；而类则是实现了这个协议，满足了这个规范的具体实例，是一个具体的概念
 * 2，接口只包含常量的方法的声明，而没有方法的实现，即其方法都是抽象方法。
 * 3，接口不允许创建对象。
 * 4，与抽象类相比较，接口中不能有非抽象的方法，但抽象类可以有
 */
public class InterfaceDemo implements MyInterface {  
	//实现MyInterface，由于MyInterface继承了两个接口，所以要实现它们所有的内容

	public void add(int x, int y) {  //实现add方法
		System.out.println("求和"+(x+y));
	}

	public void minus(int x, int y) {   //实现minus方法
		System.out.println("求差"+(x-y));
	}
	
	public static void main(String[] args) {
		InterfaceDemo d = new InterfaceDemo();
		System.out.println("常量"+a+","+b+","+c);
		d.add(5,6);
		d.minus(4, 3);
	}

}

public interface Interface1 {
	int a=8;
	void add(int x,int y);  //接口中声明的方法默认是public的
}	


public interface Interface2 {
	int b=9;
	public void minus(int x,int y);
}

public interface MyInterface extends Interface1, Interface2 {
	int c=10;
}

数组的包装类Arrays

数组的排序、数组的复制

import java.util.Arrays;

public class Trap {
	
	public static void main(String[] args) {
		int b[][] = new int [][]{
			{1},{2,3},{4,5,6}
		};
		int c[][] = Arrays.copyOf(b, 2);  //复制二维数组，两个长度
		for(int i=0;i<c.length;i++){ 	  //只要是二维数组，就算里面只有一个值，也要用两层for循环遍历才行
			for(int j=0;j<c[i].length;j++){
				System.out.print(c[i][j]);
			}
			System.out.println();
		}
		System.out.println("**********************");
//		Arrays.sort(b);                   //二维数组没办法直接用sort排序
		for(int i=0;i<b.length;i++){
			for(int j=0;j<b[i].length;j++){
				System.out.print(b[i][j]);
			}
			System.out.println();
		}
		
		int[] a ={25,1,8,5,12,9,65};
		Arrays.sort(a);                  //数组的排序，默认升序排序
		for(int i=0;i<a.length;i++){
			System.out.println(a[i]);
		} 
		
	}
		
		
}

/*
 * 举例使用数组的复制，使用数组包装类Arrays
 * 使用 Arrays.copyOfRange(数组，起始位置，长度）；
 */
public class Recopy {

		public static void main(String[] args) {
			int arr[]= new int[]{12,31,23,21,67,9};
			
			int newwarr[] = Arrays.copyOfRange(arr,0,4);
			for(int i=0;i<newwarr.length;i++){
				System.out.println(newwarr[i]);
			}
		}
}

员工工资存储系统

public class Salary {

	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		System.out.println("请输入员工数量");
		int count = s.nextInt();
		String [][] arr = new Salary().salaryArray(count); //匿名对象，调用了自己的salaryArray方法，并将员工数量传入
//		Salary sala = new Salary();						//上面的代码可以拆分成下面的两行
//		String [][] arr1=sala.salaryArray(count);		
		if(arr!=null){
			System.out.println("已保存");
		}
		//遍历员工表内容
		for(int i=0;i<arr.length;i++){
			for(int j=0;j<arr[i].length;j++){
				System.out.print(arr[i][j]);
			}
			System.out.println();
		}
	}
	
	public String[][] salaryArray(int length){
		String[][] arr = new String [length][2];
		Scanner s = new Scanner(System.in);
		for(int i=0;i<arr.length;i++){
			System.out.println("请输入员工姓名");
			String name = s.next();
			arr[i][0] = name;
			System.out.println("请输入员工工资");
			Double salary = s.nextDouble();
			arr[i][1] = salary.toString();
		}
		return arr;
	}

}

/*
 * 员工工资存储系统改版
 */
public class Salary2 {
	
	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		System.out.println("请输入员工人数");
		int n = s.nextInt();
		String[][] arr=new Salary2().salaryArray(n);  //匿名对象将员工数传入方法salaryArray中去
		if(arr!=null && arr.length !=0){
			new Salary2().salaryPring(arr); //匿名对象，将接收的赋值后的数组传入到输出方法
			System.out.println("已保存");
		}
		
	}
	
	public String[][] salaryArray(int length){  //传入员工数
		String[][] arr = new String[length][2];   //用二维数组保存姓名和工资，arr[0][0]==姓名 arr[0][1]==工资
		Scanner s = new Scanner(System.in);
		for(int i=0;i<arr.length;i++){    //用一层循环就可以将数组赋值
			System.out.println("请输入员工姓名");
			String name = s.next();
			arr[i][0]=name;
			System.out.println("请输入员工工资");
			Double salary = s.nextDouble();
			arr[i][1]= salary.toString();
		}
		return arr;								//返回的是一个数组
	}
	
	public void salaryPring(String[][] arr){ 	//该方法负责接收赋值好的数组，遍历出数组内容
		for(int i=0;i<arr.length;i++){
			System.out.println("员工姓名"+arr[i][0]+"员工工资"+arr[i][1]);
		}
	}
}

String不可变字符串相关，包含常用方法

 public class String1 {
	public static void main(String[] args) {
		char charArray[] = {'b','c','d','e','f','g','h','f','p'};
		byte byteArray[] = {-61,-26,-49,-14,-74,-44,-49,-13};
		String s,s1,s2,s3,s4,s5,s6,s7;
		s = new String("hello");         //hello
		StringBuffer buffer = new StringBuffer("Wellcome to you!");
		s1 = new String();				 //
		s2 = new String(s);				 //hello	
		s3 = new String(charArray);		 //bcdefghfp	
		s4 = new String(charArray,6,3);	 //hfp   String(数组名，起始位置，长度）
		s5 = new String(byteArray);		 //乱码
		s6 = new String(byteArray,2,4);  //乱码
		s7 = new String(buffer);         //wellcome to you!
		//String的常用方法！！
		String sa = "asdfasdfa";
		sa.length();
		sa.charAt(3);        //'f' 查找下标为3的字符串，返回的是一个 char字符 
		sa.indexOf('f');     // 3   返回当前串中第一个与制定字符相同的下标，没有则返回-1，返回 int 
		sa.indexOf('s', 3);  // 5   从下标3 开始搜索，返回找到的第一个与 ‘s’相同的字符下标  返回 int
		sa.substring(4);	 // asdfa  字符串截取，从下标为4的位置开始，截取到最后，含头
		sa.substring(3, 5);  // fa  从下标3开始截取到下标5，含头不含尾
		System.out.println(sa.substring(3, 5));
	}
  }

冒泡排序！！！！

public class test01 {

	public static void main(String[] args) {
		int arr[]= {3,4,8,7,6,5,9,1};
		int t;
		for(int i=0;i<arr.length;i++) {
			for(int j=0;j<arr.length;j++) {
				if(arr[i]<arr[j]) {
					t=arr[i];
					arr[i]=arr[j];
					arr[j]=t;
				}
			}
		}
	for(int i=0;i<arr.length;i++) {
		System.out.println(arr[i]);
	}
	}
}