JAVA基础day10

最新推荐文章于 2023-07-11 15:26:56 发布

penghui_

最新推荐文章于 2023-07-11 15:26:56 发布

阅读量385

点赞数

分类专栏： JAVA基础

本文链接：https://blog.csdn.net/penghui_/article/details/103826760

版权

JAVA基础专栏收录该内容

24 篇文章 0 订阅

订阅专栏

package com.atguigu.exer;

public class Circle extends GeometricObject{
private double radius;

public double getRadius() {
	return radius;
}

public void setRadius(double radius) {
	this.radius = radius;
}

public Circle(double radius,String color,double weight){
	super(color,weight);
	this.radius =radius;
}

public double findArea(){
	return Math.PI * radius * radius;
}

}

package com.atguigu.exer;

public abstract class GeometricObject {
protected String color;
protected double weight;

protected GeometricObject(String color,double weight){
	this.color = color;
	this.weight = weight;
}

public String getColor() {
	return color;
}

public void setColor(String color) {
	this.color = color;
}

public double getWeight() {
	return weight;
}

public void setWeight(double weight) {
	this.weight = weight;
}

public abstract double findArea();

}

package com.atguigu.exer;

public class MyRectangle extends GeometricObject{
private double width;
private double height;

public MyRectangle(double width,double height,String color,double weight){
	super(color,weight);
	this.width = width;
	this.height = height;
}

public double getWidth() {
	return width;
}

public void setWidth(double width) {
	this.width = width;
}

public double getHeight() {
	return height;
}

public void setHeight(double height) {
	this.height = height;
}

public double findArea(){
	return width * height;
}

}

package com.atguigu.exer;

public class Something {
public static void main(String[] args) {
Other o = new Other();
new Something().addOne(o);
}

public void addOne(final Other o) {
	//o = null;
	o.i++;

}

// public int addOne(final int x) {
// //return ++x;
//
// return x;
// }

}

class Other {
public int i;
}

package com.atguigu.exer;
/*

编写一个Employee类，声明为抽象类，包含如下三个属性：name，id，salary。
提供必要的构造器和抽象方法：work()。对于Manager类来说，他既是员工，
还具有奖金(bonus)的属性。请使用继承的思想，设计CommonEmployee类和Manager类，
要求类中提供必要的方法进行属性访问。

*/
class CommonEmployee extends Employee{
public void work(){
System.out.println(“在流水线工作”);
}
}

//管理者
class Manager extends Employee{
private double bonus;

public double getBonus() {
	return bonus;
}

public void setBonus(double bonus) {
	this.bonus = bonus;
}

public void work(){
	System.out.println("监督员工的工作，提高效率");
}

}
abstract class Employee{
private String name;
private int id;
private double salary;

public abstract void work();

public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}
public int getId() {
	return id;
}
public void setId(int id) {
	this.id = id;
}
public double getSalary() {
	return salary;
}
public void setSalary(double salary) {
	this.salary = salary;
}

}

public class TestEmployee {
public static void main(String[] args) {
// Manager m = new Manager();
Employee e = new Manager();
e.work();

	Employee e1 = new CommonEmployee();
	e1.work();
}

}

package com.atguigu.exer;

public class TestGeometric {
public static void main(String[] args) {
TestGeometric t = new TestGeometric();

	Circle c1 = new Circle(2.3, "Green", 1.0);
	Circle c2 = new Circle(2.3, "Red", 1.0);
	
	MyRectangle m1 = new MyRectangle(2.3, 3.0, "blue", 2.0);
	t.displayGeometricObject(c2);
	
	
	boolean b = t.equalsArea(m1, c2);
	System.out.println(b);
}

//判断两个对象的面积是否相等
public boolean equalsArea(GeometricObject o1,GeometricObject o2){

// if(o1.findArea() == o2.findArea())
// return true;
// else
// return false;
return o1.findArea() == o2.findArea();
}
public void displayGeometricObject(GeometricObject o){//GeometricObject o = new Circle(2.3, “Red”, 1.0);
System.out.println(o.findArea());
}
}

package com.atguigu.java;

class Root{
static{
System.out.println(“Root的静态初始化块”);
}
{
System.out.println(“Root的普通初始化块”);
}
public Root(){
System.out.println(“Root的无参数的构造器”);
}
}
class Mid extends Root{
static{
System.out.println(“Mid的静态初始化块”);
}
{
System.out.println(“Mid的普通初始化块”);
}
public Mid(){
System.out.println(“Mid的无参数的构造器”);
}
public Mid(String msg){
//通过this调用同一类中重载的构造器
this();
System.out.println(“Mid的带参数构造器，其参数值：”
+ msg);
}
}
class Leaf extends Mid{
static{
System.out.println(“Leaf的静态初始化块”);
}
{
System.out.println(“Leaf的普通初始化块”);
}
public Leaf(){
//通过super调用父类中有一个字符串参数的构造器
super(“尚硅谷”);
System.out.println(“执行Leaf的构造器”);
}
}
public class TestLeaf{
public static void main(String[] args){
new Leaf();
System.out.println();
new Leaf();
}
}

package com.atguigu.java;

public class TestMain {
//主方法，是程序的入口
public static void main(String[] args) {
for(int i = 0;i < args.length;i++){
System.out.println(args[i]);
}
}
}

package com.atguigu.java;

public class TestMain1 {
public static void main(String[] args) {
Main.main(new String[1000]);
}
}

class Main{

public static void main(String[] args){
	for(int i = 0;i < args.length;i++){
		args[i] = "value_" + i;
		System.out.println(args[i]);
	}
}

}

package com.atguigu.java;

类的第四个成员：初始化块（或代码块）
1.代码块如果有修饰的话，那么只能使用static。
2.分类：
静态代码块：
1.里面可以有输出语句
2.随着类的加载而加载，而且只被加载一次
3.多个静态代码块之间按照顺序结构执行
4.静态代码块的执行要早于非静态代码块的执行。
5.静态的代码块中只能执行静态的结构(类属性，类方法)
非静态代码块：
1.可以对类的属性(静态的 & 非静态的)进行初始化操作，同时也可以调用本类声明的方法(静态的 & 非静态的)
2.里面可以有输出语句
3.一个类中可以有多个非静态的代码块，多个代码块之间按照顺序结构执行
4.每创建一个类的对象，非静态代码块就加载一次。
5.非静态代码块的执行要早于构造器
关于属性赋值的操作：①默认的初始化②显式的初始化或代码块初始化(此处两个结构按照顺序执行) ③构造器中；④通过方法对对象的相应属性进行修改
*/
public class TestOrder {
public static void main(String[] args) {
Order o1 = new Order();
System.out.println(o1);
```
 System.out.println();

 Order o2 = new Order();
 System.out.println(o2);
```
}
}

class Order {

private String orderName;
private int orderId = 1001;
private static String orderDesc;
public Order() {
	super();
	System.out.println("我是Order类的空参的构造器");
}
//非静态的初始化块
{
	orderId = 1002;
	orderName = "AA";
	System.out.println("我是非静态代码块1");
	orderDesc = "ORDER";
	show1();
	show2();
}
{
	orderId = 1003;
	System.out.println("我是非静态代码块2");
}
//静态的代码块
static{
	System.out.println("静态代码块2");
	orderDesc = "我是一个Order";

// orderId = 1000;
// show1();
show2();
}
static{
System.out.println(“静态代码块1”);
}

public Order(int orderId, String orderName) {
	super();
	this.orderId = orderId;
	this.orderName = orderName;
}

public int getOrderId() {
	return orderId;
}

public void setOrderId(int orderId) {
	this.orderId = orderId;
}

public String getOrderName() {
	return orderName;
}

public void setOrderName(String orderName) {
	this.orderName = orderName;
}

@Override
public String toString() {
	return "Order [orderId=" + orderId + ", orderName=" + orderName + "]";
}
public void show1(){
	
}
public static void show2(){
	
}

}

package com.atguigu.java;
/*

设计模式：设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。
23种设计模式。
单例的设计模式：
1.解决的问题：使得一个类只能够创建一个对象。
2.如何实现？见如下的4步
*/
//饿汉式
public class TestSingleton {
public static void main(String[] args) {
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
System.out.println(s1 == s2);
}
}
//只能创建Singleton的单个实例
class Singleton{

//1.私有化构造器，使得在类的外部不能够调用此构造器
private Singleton(){

}
//2.在类的内部创建一个类的实例
private static Singleton instance = new Singleton();
//3.私有化此对象，通过公共的方法来调用
//4.此公共的方法，只能通过类来调用，因为设置为static的,同时类的实例也必须为static声明的
public static Singleton getInstance(){
return instance;
}

}

package com.atguigu.java;
//懒汉式:可能存在线程安全问题的
public class TestSingleton1 {
public static void main(String[] args) {
Singleton1 s1 = Singleton1.getInstance();
Singleton1 s2 = Singleton1.getInstance();
System.out.println(s1 == s2);

}
class Singleton1{
//1.
private Singleton1(){

}
//2.
private static Singleton1 instance = null;
//3.
public static Singleton1 getInstance(){
	
	if(instance == null){
		
		instance = new Singleton1();
	}
	return instance;
}

}

package com.atguigu.java1;
/*

abstract:抽象的,可以用来修饰类、方法
1.abstract修饰类：抽象类
1)不可被实例化
2)抽象类有构造器 (凡是类都有构造器)
3)抽象方法所在的类，一定是抽象类。
4)抽象类中可以没有抽象方法。
2.abstract修饰方法：抽象方法
1)格式：没有方法体，包括{}.如：public abstract void eat();
2)抽象方法只保留方法的功能，而具体的执行，交给继承抽象类的子类，由子类重写此抽象方法。
3)若子类继承抽象类，并重写了所有的抽象方法，则此类是一个"实体类",即可以实例化
4)若子类继承抽象类，没有重写所有的抽象方法，意味着此类中仍有抽象方法，则此类必须声明为抽象的！

*/
public class TestAbstract {
public static void main(String[] args) {
//Person p1 = new Person();
//p1.eat();

	Student s = new Student();
	s.eat();
	
	Person p = new Student();//多态
	p.eat();
	
}

}

abstract class Creator{
abstract void breath();
}

abstract class Person extends Creator{
String name;
public abstract void eat();
public abstract void walk();

public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}
public Person(){
	
}
public Person(String name){
	this.name = name;
}

}
class Student extends Person{
public void eat(){
System.out.println(“学生吃饭”);
}
public void walk(){
System.out.println(“学生走路”);
}
@Override
void breath() {
System.out.println(“学生不应该呼吸雾霾的空气”);
}
}

abstract class Worker extends Person{
public void eat(){
System.out.println(“工人吃饭”);
}
// public void walk(){
// System.out.println(“工人走路”);
// }
}

class Animal{
//不是抽象方法！
public void sleep(){

}

package com.atguigu.java1;
//abstract 不能用来修饰属性、构造器、private、final、static
public class TestAbstract1 {

}

abstract class A1{
//abstract int name;
//因为构造器不能被重写
// public abstract A1(){
//
// }
//子类不能覆盖（或重写）声明为private的方法的。
//private abstract void method1();

//

// public abstract final void method2();
//
//
// public abstract static void method3();
//
//
}

package com.atguigu.java1;
/*

final:最终的，可以用来修饰类、属性、方法
1.final修饰类：这个类就不能被继承。如：String类、StringBuffer类、System类
2.final修饰方法：不能被重写。如：Object类的getClass()
3.final修饰属性：此属性就是一个常量，一旦初始化后，不可再被赋值。习惯上，常量用大写字符表示。
此常量在哪里赋值：①此常量不能使用默认初始化 ②可以显式的赋值、代码块、构造器。
变量用static final修饰：全局常量
与finally finalize()区分开

*/
public class TestFinal {
public static void main(String[] args) {
C c = new C();
System.out.println(c.getClass());
System.out.println(Math.PI);
}
}

class D{
final int I = 12;
final double PI;
final String NAME;

public void m1(){
	System.out.println(I);

// I = 10;

}
{
	PI = 3.14;
}

public D(){
	NAME = "DD";
}
public D(String name){
	this();
	//NAME = name;
}

}

//class SubString extends String{
//
//}
final class A{

}
//class B extends A{
//
//}
class C{
public final void method1(){
System.out.println(“method1”);
}
}

class E extends C{
// public void method1(){
// System.out.println(“method1…”);
// }
}

package com.atguigu.java1;
/*

接口（interface）是与类并行的一个概念
1.接口可以看做是一个特殊的抽象类。是常量与抽象方法的一个集合，不能包含变量、一般的方法。
2.接口是没有构造器的。
3.接口定义的就是一种功能。此功能可以被类所实现（implements）。
比如：class CC extends DD implements AA
4.实现接口的类，必须要重写其中的所有的抽象方法，方可实例化。若没有重写所有的抽象方法，则此类仍为一个抽象类
5.类可以实现多个接口。----java 中的类的继承是单继承的
6.接口与接口之间也是继承的关系，而且可以实现多继承
5,6描述的是java中的继承的特点。

*/
public class TestInterface {
public static void main(String[] args) {
System.out.println(AA.I);
// AA.I = 13;
}
}

interface AA{
//常量:所有的常量都用public static final修饰
int I = 12;
boolean FLAG = false;
// int i;
//抽象方法:所有的都用public abstract修饰
void method1();
void method2();
}

abstract class BB implements AA{

}
class DD{

}
interface MM{
void method3();
}
class CC extends DD implements AA,MM{
public void method1(){

}
public void method2(){
	
}
public void method3(){
	
}

}
//接口之间仍为继承关系！(多继承)
interface JJ extends MM,AA{
void method4();
}

class GG implements JJ{

@Override
public void method3() {
	// TODO Auto-generated method stub
	
}

@Override
public void method4() {
	// TODO Auto-generated method stub
	
}

@Override
public void method1() {
	// TODO Auto-generated method stub
	
}

@Override
public void method2() {
	// TODO Auto-generated method stub
	
}

}

package com.atguigu.java1;

//模板方法设计模式
public class TestTemplate {
public static void main(String[] args) {
new SubTemplate().spendTime();
}
}

abstract class Template {

public abstract void code();

public void spendTime() {
	long start = System.currentTimeMillis();

	this.code();

	long end = System.currentTimeMillis();
	System.out.println("花费的时间为：" + (end - start));
}

}

class SubTemplate extends Template {

public void code() {
	boolean flag = false;
	for(int i = 2;i <= 10000;i++){
		for(int j = 2;j <= Math.sqrt(i);j++){
			if(i % j == 0){
				flag = true;
				break;
			}
		}
		if(!flag){
			System.out.println(i);
		}
		flag = false;
	}
}

}

package com.atguigu.review;

import java.util.Date;

public class Test {
public static void main(String[] args) {
String str = new String(“AA”);
System.out.println(str);

	Date d = new Date();
	System.out.println(d.toString());
	
	Integer i = new Integer(10);
	System.out.println(i.toString());
}

}

package com.atguigu.review;

public class TestCircle {
public static void main(String[] args) {
Circle c1 = new Circle();
Circle c2 = new Circle(2.3);
System.out.println(c1);
System.out.println(c2);
System.out.println(Circle.getTotal());
}
}

class Circle{
private double radius;
private static String info = “我是一个圆”;
private int id;//编号
private static int init = 1001;//控制每个对象的id
private static int total = 0;//记录创建了多少个对象

public Circle(){
	this.id = init++;
	total++;
}
public Circle(double radius){
	this.radius = radius;
	this.id = init++;
	total++;
}



public double getRadius() {
	return radius;
}
public void setRadius(double radius) {
	this.radius = radius;
}
public static String getInfo() {
	return info;
}
public static void setInfo(String info) {
	Circle.info = info;
}
public int getId() {
	return id;
}
public void setId(int id) {
	this.id = id;
}
public static int getTotal() {
	return total;
}
public static void setTotal(int total) {
	Circle.total = total;
}
@Override
public String toString() {
	return "Circle [radius=" + radius + ", id=" + id + "]";
}
public static void show(){
	System.out.println(Circle.info);
}

public void desc(){
	System.out.println(this.info);
}

}