一个蒟蒻萌新的Java之路

于 2018-09-05 20:11:53 发布
阅读量333 收藏 1
点赞数 4
CC 4.0 BY-SA版权
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Nothwest__Green/article/details/82429351
本文从Java初学者的角度出发，介绍了HelloWorld程序的编写，并深入探讨了Java输入输出操作、数组处理、流程控制等基本概念。此外，文章还详细讲解了Java中的类继承、抽象类与接口的区别及应用，以及方法的重写与重载等内容。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

2018.8.9 HelloWorld！

  闲来无事，想起了还有java这个世界上最好的语言（别再强调是PHP了~

  人生第一个用java实现的Hellworld，纪念一下！

			
public class HelloWorld {
		public static void main(String []args) {
			System.out.println("Hello World!");
		}
}

  一入此门深似海呐，了解了java的输入输出，数组的创建。通过 Scanner 类的 next() 与 nextLine() 方法获取输入的字符串，在读取前我们一般需要 使用 hasNext 与 hasNextLine 判断是否还有输入的数据。

import java.util.Scanner;

public class Test1 {
	public static void main(String[] args) {
		Scanner io = new Scanner(System.in);
		int min = 1000;
		int[] array = new int [10];
		for(int i = 0; i < 10; i++) {
			array[i] = io.nextInt();
		}
		for(int i = 0; i < 10; i++) {
			if(array[i] < min)
				min = array[i];
		}
		System.out.println(min);
	}
}

 2018.8.10 Are you sure？

   菜鸡第二天看完清华大神郑莉老师的视频才知道，原来输入流还要关闭。

import java.util.Scanner;

public class Test2 {
	public static void main(String[] args) {
		Scanner io = new Scanner(System.in);
		int[] array = new int [10];
		for(int i = 0; i < 10; i++) {
			array[i] = io.nextInt();
		}
		io.close();
		int tmp;
		for(int i = 0; i < 10; i++) {
			for(int j = 0; j < 9-i; j++) {
				if(array[j] > array[j+1]) {
					tmp = array[j];
					array[j] = array[j+1];
					array[j+1] = tmp;
			    }
			}
		}
		for(int i = 0; i < 10; i++) {
			System.out.print(array[i] + " ");
		}
	}
}

2018.8.11 回车一下

next() 与 nextLine() 区别

next():

  1. 一定要读取到有效字符后才可以结束输入。

  2. 对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。

  3. 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。

  4. next() 不能得到带有空格的字符串。

nextLine()：

  1. 以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
  2. 可以获得空白。
import java.util.Scanner;
 
public class Test3 {
    public static void main(String[] args) {
        Scanner io = new Scanner(System.in);
        int i = 0;
        float f = 0.0f;
        System.out.print("输入整数：");
        if (io.hasNextInt()) {
            i = io.nextInt();
            System.out.println("整数数据：" + i);
        } 
        else {
            System.out.println("输入的不是整数！");
        }
        System.out.print("输入小数：");
        if (io.hasNextFloat()) {
            f = io.nextFloat();
            System.out.println("小数数据：" + f);
        } 
        else {
            System.out.println("输入的不是小数！");
        }
        io.close();
    }
}

  

2018.9.6 lili姐画了一节课流程图+Java继承 

  lili姐说没事多练练……眼过千遍，不如手过一遍（当然也看不了一千遍

Java继承

  继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

 类的继承格式

  在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的，一般形式如下：

class 父类 {
}
 
class 子类 extends 父类 {
}

继承类型

  需要注意的是 Java 不支持多继承，但支持多重继承。

  

继承的特性

  • 子类拥有父类非private的属性，方法。

  • 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

  • 子类可以用自己的方式实现父类的方法。

  • Java的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如A类继承B类，B类继承C类，所以按照关系就是C类是B类的父类，B类是A类的父类，这是java继承区别于C++继承的一个特性。

  • 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

  • 继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承object（这个类在 java.lang 包中，所以不需要 import）祖先类。

  extends关键字 

  在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。

public class Person { 
    private String name;   
    private int id; 
    public Person(String Name, String Id) { 
        //初始化
    } 
    public void eat() {  //吃饭属性的实现  } 
    public void sleep() { //睡觉属性的实现  } 
} 
 
public class Boy  extends  Person{ 

}

implements关键字

  规矩是死的，人是活的！！！

使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口。

public interface A {
    public void eat();
    public void sleep();
}
 
public interface B {
    public void show();
}
 
public class C implements A,B {

}

super 与 this 关键字

super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

this关键字：指向自己的引用。


class Person {
    void eat() {
    	System.out.println("Person : eat");
    }
}
 
class Boy extends Person {
    void eat() {
    	System.out.println("Boy : eat more");
    }
    void eatTest() {
    	this.eat();   // this 调用自己的方法
    	super.eat();  // super 调用父类方法
    }
}
 
public class Test10 {
	public static void main(String[] args) {
	    Person p = new Person();
	    //p.eat();
	    Boy b = new Boy();
	    b.eatTest();
	}
}

final关键字

final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写。

final class 类名 {
    //类体
}

2018.9.13 Java重写Override与重载Overload

  lili姐频繁拿对象数组举例，我连对象都。。。摊手

重写Override

重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。

当需要在子类中调用父类的被重写方法时，要使用super关键字。

class Persons extends Object{
		private String Name;
		private int Age;
		private int High;
		
		public String getName() {
			return Name;
		}
		public int getAge() {
			return Age;
		}
		public int getHigh() {
			return High;
		}
	
		public Persons(String name,int age,int high) {
			this.Name = name;
			this.Age = age;
			this.High = high;
		}
		
		//重写string
		public String toString() {
			return (Name + " " + Age + " " + High);
		}
}

public class Test12 {

	public static void main(String[] args) {
			
		int n,age,high;
		String name;
		Persons[] people = new Persons[5];

		people[0] = new Persons("Peter",17,175);
		people[1] = new Persons("Alice",18,176);
		people[2] = new Persons("Rose",19,177);
		people[3] = new Persons("Tom",20,178);
		people[4] = new Persons("Grown",21,179);
			
	        for(int i = 0; i < people.length; i++) {
				System.out.println(people[i]);
		}
}

 重载Overload

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。

每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。

最常用的地方就是构造器的重载。

重载规则

  • 被重载的方法必须改变参数列表(参数个数或类型不一样)。
  • 被重载的方法可以改变返回类型。
  • 被重载的方法可以改变访问修饰符。
  • 被重载的方法可以声明新的或更广的检查异常。
  • 方法能够在同一个类中或者在一个子类中被重载。
  • 无法以返回值类型作为重载函数的区分标准。 

小结

方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现，重写是父类与子类之间多态性的一种表现，重载可以理解成多态的具体表现形式。

2018.10.11 Java抽象类与接口

抽象类 （abstract）

在Java语言中使用abstract class来定义抽象类。 

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。

父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。

在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。 

抽象方法

abstract关键字同样可以用来声明抽象方法，抽象方法只包含一个方法名，而没有方法体。

抽象方法没有定义，方法名后面直接跟一个分号。

public abstract class Shape
{
   private double length;
   
   public abstract double getArea();    //获取面积
   
   public abstract double getCircumference();   //获取周长

   //其余代码
}

敲黑板！！！

  • 如果一个类包含抽象方法，那么该类必须是抽象类。
  • 任何子类必须重写父类的抽象方法，或者声明自身为抽象类。
class Circle extends Shape{
	
	public double getArea() {
		return length * length * Math.PI;
	}
	
        public double getCircumference() {
                return Math.PI * length * 2;
        }
}

 小结

  • 抽象类不能被实例化，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。

  • 抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现。

  • 构造方法，类方法（用static修饰的方法）不能声明为抽象方法。

  • 抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。

接口（interface）

接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法，接口则包含类要实现的方法。

接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。

声明：

[可见度] interface 接口名称 [extends 其他的接口名名] {
        // 声明变量
        // 抽象方法
}

定义接口 ：

public interface Shape {
	public double getArea();
}

 实现接口：

class Circle implements Shape{
	double length;
	public double getArea() {
		return length * length * Math.PI;
	}
	Circle(double r) {
		length = r;
	}
}
class Rectangle implements Shape{
	double length;
	double width;
	public double getArea() {
		return length * width;
	}
	Rectangle(double l,double w) {
		length = l;
		width = w;
	}
}
public class Test1 {
	public static void main(String[] args) {
		Circle c = new Circle(2);
		Rectangle r = new Rectangle(4,5);
		System.out.println(c.getArea());
		System.out.println(r.getArea());
	}
}

运行结果： 

12.566370614359172
20.0

接口特点： 

  • 接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字。
  • 接口中每一个方法也是隐式抽象的，声明时同样不需要abstract关键字。
  • 接口中的方法都是公有的。

接口与类相似点：

  • 一个接口可以有多个方法。
  • 接口文件保存在 .java 结尾的文件中，文件名使用接口名。

接口与类的区别： 

  • 接口不能用于实例化对象。
  • 接口没有构造方法。
  • 接口中所有的方法必须是抽象方法。
  • 接口不能包含成员变量，除了 static 和 final 变量。
  • 接口不是被类继承了，而是要被类实现。
  • 接口支持多继承。

接口和抽象类的区别 ：

  • 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
  • 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
  • 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

 

 

评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值