MySQL学习笔记
ChildGame.java
package com.hspedu.static_;
public class ChildGame {
public static void main(String[] args) {
//定义一个变量count,统计有多少小孩加入游戏
int count = 0;
Child child1 = new Child("小明");
child1.join();
count++;
Child child2 = new Child("小红");
child1.join();
count++;
Child child3 = new Child("小辉");
child1.join();
count++;
System.out.println("共有" + count + "名小孩加入了游戏");
}
}
class Child {
private String name;
public Child(String name) {
this.name = name;
}
public void join(){
System.out.println(name + "加入了游戏");
}
}
ChildGame.java
package com.hspedu.static_;
public class ChildGame {
public static void main(String[] args) {
Child child1 = new Child("小明");
child1.join();
child1.count++;
Child child2 = new Child("小红");
child1.join();
child2.count++;
Child child3 = new Child("小辉");
child1.join();
child3.count++;
//类变量，可以通过类名来访问
System.out.println("共有" + Child.count + "名小孩加入了游戏");
//下面的代码输出的都是3
System.out.println("child1.count=" +child1.count);
System.out.println("child2.count=" +child2.count);
System.out.println("child3.count=" +child3.count);
}
}
class Child {
private String name;
//定义一个变量count,是一个类变量(静态变量)
//该变量最大的特点就是会被Child类的所有对象实例共享
public static int count = 0;
public Child(String name) {
this.name = name;
}
public void join(){
System.out.println(name + "加入了游戏");
}
}
https;//blog.csdn.net/x_iya/article/details/81260154/ https://www.zhihu.com/question/59174759/answer/163207831
VisitStatic.java
package com.hspedu.static_;
public class VisitStatic {
public static void main(String[] args) {
//类名.类变量名
//类变量是随着类的加载而创建,所以即使没有创建对象实例也可以访问
System.out.println(A.name);
A a = new A();
//通过对象名.类变量名
System.out.println("a.name = " + a.name);
//类变量的访问，必须遵守相关的访问权限
//System.out.println(A.edu);
}
}
class A {
//类变量
public static String name = "韩顺平教育";
//类变量的访问，必须遵守相关的访问权限
private static String edu = "韩顺平教育";
//普通属性/普通成员变量/非静态成员变量/非静态属性/实例变量
private int num = 10;
}
StaticDetail.java
package com.hspedu.static_;
public class StaticDetail {
public static void main(String[] args) {
B b = new B();
//5.实例变量不能通过类名.类变量名方式进行访问
//System.out.println(B.n1);
System.out.println(B.n2);
//6.静态变量是类加载的时候就创建了，所以我们没有创建对象实例，也可以通过类名.类变量名来访问
System.out.println(C.address);
}
}
class B {
public int n1 = 100;
public static int n2 = 200;
}
class C{
public static String address = "北京";
}
StaticMethod.java
package com.hspedu.static_;
public class StaticMethod {
public static void main(String[] args) {
Stu tmo = new Stu("tmo");
//tmo.payFee(100);//正确
Stu.payFee(100);//正确
Stu mary = new Stu("mary");
Stu.payFee(200);//正确
//mary.payFee(200);//正确
//输出当前收到的总学费
Stu.shouFee();//300
//如果我们希望不创建实例，也可以调用某个方法，把方法做成静态方法时非常适合
System.out.println("9开平方的结果=" + Math.sqrt(9));
System.out.println(MyTools.calSum(10,30));
}
}
class Stu{
private String name;
//定义一个静态变量，来累计学生学费
private static double fee = 0;
public Stu(String name) {
this.name = name;
}
//1.当方法使用了static方法修饰后，该方法就是静态方法
//2.静态方法就可以访问静态属性变量
public static void payFee(double fee){
Stu.fee += fee;
}
public static void shouFee(){
System.out.println("总学费有：" + Stu.fee);
}
}
//开发自己的工具类时，可以将方法做成静态的，方便调用
class MyTools{
public static double calSum(double n1,double n2){
return n1+n2;
}
}
StaticMethodDetail.java
package com.hspedu.static_;
public class StaticMethodDetail {
public static void main(String[] args) {
D.hi();//ok
//D.say();//错误，3.非静态方法不能通过类名调用，需要先创建对象再调用
D d = new D();
d.say();
}
}
class D {
private int n1 = 100;
private static int n2 = 200;
public void say(){
}
public static void hi(){
//4.类方法中不允许使用和对象有关的关键字，比如this和super,普通方法(成员方法)可以
//System.out.println(this.n1);//错误
}
//5.类方法中,只能访问静态变量或者静态方法
//口诀:静态方法只能访问静态成员
public static void hello(){
System.out.println(n2);//ok
System.out.println(D.n2);//ok
//System.out.println(n1);//错误
//System.out.println(this.n2);//错误
hi();//ok
//say();//错误
}
//普通成员方法，即可访问非静态成员，也可以访问静态成员
//小结：非静态方法可以访问静态成员和非静态成员
public void ok(){
//非静态成员
System.out.println(n1);
say();
//静态成员
System.out.println(n2);
hello();
}
}
Hello.java
public class Hello {
public static void main(String[] args){
//args是如何传入
//遍历显示
for(int i = 0;i < args.length;i++){
System.out.println("第"+ (i+1) + "个参数=" + args[i]);
}
}
}
Main01.java
package com.hspedu.main;
public class Main01 {
//静态变量/属性
private static String name = "韩顺平教育";
//静态方法
public static void hi(){
System.out.println("Main01的hi方法");
}
//非静态变量/属性
private int n1 = 10000;
//非静态方法
public void cry(){
System.out.println("Main01的cry方法");
}
public static void main(String[] args) {
//可以直接使用name
//1.静态方法main 可以访问本类的静态成员
System.out.println("name=" + name);
hi();
//2.静态方法main不可以访问本类的非静态成员
//System.out.println("n1=" + n1);//错误
//cry();//错误
//3.如果静态方法main要访问本类的非静态成员，需要先创建对象，再调用即可
Main01 main01 = new Main01();//ok
System.out.println(main01.n1);//ok
main01.cry();//ok
}
}
Main02.java
package com.hspedu.main;
public class Main02 {
public static void main(String[] args) {
for (int i = 0; i < args.length; i++) {
System.out.println("args[" + i + "] = " + args[i]);
}
}
}
//
//args[0] = 北京
//...
CodeBlock01.java
package com.hspedu.codeblock_;
public class CodeBlock01 {
public static void main(String[] args) {
Movie movie = new Movie("你好，李焕英");
System.out.println("=============");
new Movie("唐人街探案",100,"陈思诚");
}
}
class Movie{
private String name;
private double price;
private String director;
//3个构造器->重载
//1.下面单个构造器都有相同的语句
//2.代码比较冗余
//3.可以把相同的语句放在一个代码块中
//4.当我们不管调用哪个构造器创建对象，都会先调用代码块的内容
//5.代码块调用的顺序优先于构造器
{
System.out.println("电影屏幕打开...");
System.out.println("广告开始...");
System.out.println("电影正式开始...");
}
public Movie(String name) {
// System.out.println("电影屏幕打开...");
// System.out.println("广告开始...");
// System.out.println("电影正式开始...");
System.out.println("Movie(String name)构造器被调用");
this.name = name;
}
public Movie(String name, double price) {
// System.out.println("电影屏幕打开...");
// System.out.println("广告开始...");
// System.out.println("电影正式开始...");
System.out.println("Movie(String name, double price)构造器被调用");
this.name = name;
this.price = price;
}
public Movie(String name, double price, String director) {
// System.out.println("电影屏幕打开...");
// System.out.println("广告开始...");
// System.out.println("电影正式开始...");
System.out.println("Movie(String name, double price, String director)构造器被调用");
this.name = name;
this.price = price;
this.director = director;
}
}
CodeBlockDetail01.java
package com.hspedu.codeblock_;
public class CodeBlockDetail01 {
public static void main(String[] args) {
//类被加载的情况举例：
// 1.创建对象实例时（new）
//AA aa = new AA();
/**
* AA的静态代码块1被执行...
*/
//2.创建子类对象实例，父类也会被加载,而且父类先被加载，子类后被加载
//AA aa2 = new AA();
/**
*BB的静态代码块1被执行...
*AA的静态代码块1被执行...
*/
//3.使用类的静态成员时(静态属性，静态方法)
//System.out.println(Cat.n1);
/**
* Animal的静态代码1被执行...
* Cat的静态代码1被执行...
* 999
*/
//static代码块是在类加载时执行的，而且只会执行一次
//DD dd = new DD();
//DD dd1 = new DD();
/**
* DD的静态代码1被执行...
* DD的静普通代码块...
* DD的静普通代码块...
*/
//普通的代码块，在创建对象实例时，会被隐式的调用。
//被创建一次，就会调用一次。如果只是使用类的静态成员时，普通代码块并不会执行
System.out.println(DD.n1);
/**
* DD的静态代码1被执行...
* 8888
*/
}
}
class DD {
public static int n1 = 8888;//静态属性
//静态代码块
static {
System.out.println("DD的静态代码1被执行...");
}
//普通代码块,在new对象时，被调用，每创建一个对象，就调用一次
{
System.out.println("DD的静普通代码块...");
}
}
class Animal {
static {
System.out.println("Animal的静态代码1被执行...");
}
}
class Cat extends Animal{
public static int n1 = 999;//静态属性
//静态代码块
static {
System.out.println("Cat的静态代码1被执行...");
}
}
class BB{
//静态代码块
static {
System.out.println("BB的静态代码块1被执行...");
}
}
class AA extends BB{
//静态代码块
static {
System.out.println("AA的静态代码块1被执行...");
}
}
CodeBlockDetail02.java
package com.hspedu.codeblock_;
public class CodeBlockDetail02 {
public static void main(String[] args) {
A a = new A();
/**
* getN1被调用...
* A 静态代码块01
* getN2被调用...
* A 普通代码块01
* A()构造器被调用
*/
}
}
class A{
private int n2 = getN2();//普通属性的初始化
{//普通代码块
System.out.println("A 普通代码块01");
}
//静态属性的初始化
private static int n1 = getN1();
static {//静态代码块
System.out.println("A 静态代码块01");
}
public static int getN1(){
System.out.println("getN1被调用...");
return 100;
}
public int getN2(){
System.out.println("getN2被调用...");
return 200;
}
//无参构造器
public A() {
System.out.println("A()构造器被调用");
}
}
CodeBlockDetail03.java
package com.hspedu.codeblock_;
public class CodeBlockDetail03 {
public static void main(String[] args) {
new BBB();
/**
* AAA的普通代码块...
* AAA()构造器被调用...
* BBB的普通代码块
* BBB()构造器被调用...
*/
}
}
class AAA{
{
System.out.println("AAA的普通代码块...");
}
public AAA() {
//1.隐藏super();
//2.调用本类的普通代码块
System.out.println("AAA()构造器被调用...");
}
}
class BBB extends AAA{
{
System.out.println("BBB的普通代码块");
}
public BBB() {
//1.隐藏super();
//2.调用本类的普通代码块
System.out.println("BBB()构造器被调用...");
}
}
CodeBlockDetail04.java
package com.hspedu.codeblock_;
public class CodeBlockDetail04 {
public static void main(String[] args) {
//老师说明
//(1) 进行类的加载
//1.1 先加载 父类 A02
//1.2 再加载 B02
//(2) 创建对象
//2.1 从子类的构造器开始
new B02();//对象
/**
* getVal01
* A02的一个静态代码块..
* getVal03
* B02的一个静态代码块..
* A02的第一个普通代码块..
* getVal02
* A02的构造器
* getVal04
* B02的第一个普通代码块..
* B02的构造器
*/
//new C02();
}
}
class A02 { //父类
private static int n1 = getVal01();
static {
System.out.println("A02的一个静态代码块..");//(2)
}
{
System.out.println("A02的第一个普通代码块..");//(5)
}
public int n3 = getVal02();//普通属性的初始化
public static int getVal01() {
System.out.println("getVal01");//(1)
return 10;
}
public int getVal02() {
System.out.println("getVal02");//(6)
return 10;
}
public A02() {//构造器
//隐藏
//super()
//普通代码和普通属性的初始化......
System.out.println("A02的构造器");//(7)
}
}
class B02 extends A02 { //
private static int n3 = getVal03();
static {
System.out.println("B02的一个静态代码块..");//(4)
}
public int n5 = getVal04();
{
System.out.println("B02的第一个普通代码块..");//(9)
}
public static int getVal03() {
System.out.println("getVal03");//(3)
return 10;
}
public int getVal04() {
System.out.println("getVal04");//(8)
return 10;
}
//一定要慢慢的去品..
public B02() {//构造器
//隐藏了
//super()
//普通代码块和普通属性的初始化...
System.out.println("B02的构造器");//(10)
// TODO Auto-generated constructor stub
}
}
class C02 {
private int n1 = 100;
private static int n2 = 200;
private void m1() {
}
private static void m2() {
}
static {
//静态代码块，只能调用静态成员
//System.out.println(n1);错误
System.out.println(n2);//ok
//m1();//错误
m2();
}
{
//普通代码块，可以使用任意成员
System.out.println(n1);
System.out.println(n2);//ok
m1();
m2();
}
}
package com.hspedu.codeblock_;
public class CodeBlockExercise01 {
}
class Person {
public static int total;//静态变量
static {//静态代码块
total = 100;
System.out.println("in static block!");//(1)
}
}
class Test1 {
public static void main(String[] args) {
System.out.println("total = "+ Person.total); //100
System.out.println("total = "+ Person.total); //100
}
}
/**
* in static block!
* total = 100
* total = 100
*/
package com.hspedu.codeblock_;
public class CodeBlockExercise02 {
}
class Sample
{
Sample(String s)
{
System.out.println(s);
}
Sample()
{
System.out.println("Sample默认构造函数被调用");
}
}
class Test{
Sample sam1=new Sample("sam1成员初始化");//
static Sample sam=new Sample("静态成员sam初始化 ");//
static{
System.out.println("static块执行");//
if(sam==null)System.out.println("sam is null");
}
Test()//构造器
{
System.out.println("Test默认构造函数被调用");//
}
//主方法
public static void main(String str[])
{
Test a=new Test();//无参构造器
}
}
/**
* 静态成员sam初始化
* static块执行
* sam1成员初始化
* Test默认构造函数被调用
*/
SingleTon01.java
package com.hspedu.single_;
public class SingleTon01 {
public static void main(String[] args) {
//GirlFriend xh = new GirlFriend("小红");
//GirlFriend xb = new GirlFriend("小白");
//通过方法可以获得对象
System.out.println(GirlFriend.getInstance());
GirlFriend instance1 = GirlFriend.getInstance();
System.out.println(instance1);
GirlFriend instance2 = GirlFriend.getInstance();
System.out.println(instance2);
System.out.println(instance1 == instance2);
/**
* GirlFriend{name='小红红'}
* GirlFriend{name='小红红'}
* GirlFriend{name='小红红'}
* true
*/
System.out.println(GirlFriend.n1);
/**
* 构造器被调用
* 100
*/
//饿汉式:在执行上面语句时，还没有用到gf对象，但是处于类的机制，gf对象已经创建好了
}
}
//有一个类 GirlFriend
//只能有一个女朋友
class GirlFriend{
private String name;
public static int n1 = 100;
//为了能够在静态方法中 ，返回gf对象，需要将其修饰为static
//对象通常是重量级的对象，饿汉式可能造成创建了对象，但是没有使用
private static GirlFriend gf = new GirlFriend("小红红");
//如何保证只能创建一个GirlFriend对象
//步骤[单例模式-饿汉式]:
//1.将构造器私有化
//2.在类的内部直接创建对象(该对象是static)
//3.提供一个公共的static方法,返回gf对象
private GirlFriend(String name) {
System.out.println("构造器被调用");
this.name = name;
}
public static GirlFriend getInstance(){
return gf;
}
@Override
public String toString() {
return "GirlFriend{" +
"name='" + name + '\'' +
'}';
}
}
SingleTon02.java
package com.hspedu.single_;
/**
* 演示懒汉式的单例模式
*/
public class SingleTon02 {
public static void main(String[] args) {
System.out.println(Cat.n1);//999
Cat instance = Cat.getInstance();
System.out.println(instance);
//再次调用getInstance
Cat instance2 = Cat.getInstance();
System.out.println(instance2);
System.out.println(instance == instance2);
/**
* 999
* 构造器被调用...
* Cat{name='小可爱'}
* Cat{name='小可爱'}
* true
*/
}
}
//希望在程序运行过程中，只能创建一个Cat对象
//使用单例模式
class Cat {
private String name;
public static int n1 = 999;
private static Cat cat;//默认为null
//步骤
//1.构造器私有化
//2.定义一个static静态属性对象
//3.提供一个public的static方法，可以返回一个Cat对象
//4.懒汉式，只有当用户使用getInstance时，才返回cat对象，后面再次调用时，会返回上次创建的cat对象,保证单例
public Cat(String name) {
System.out.println("构造器被调用...");
this.name = name;
}
public static Cat getInstance(){
if(cat == null){
cat = new Cat("小可爱");
}
return cat;
}
@Override
public String toString() {
return "Cat{" +
"name='" + name + '\'' +
'}';
}
}
Final01.java
package com.hspedu.final_;
public class Final01 {
public static void main(String[] args) {
//3.当不希望类的某个属性的值被修改，可以用final修饰
//E e = new E();
//e.TAX_RATE = 0.09;错误
}
}
//1.如果我们要求A类不能被其他类继承，可以使用final修饰A类
final class A{
}
//class B extends A{
//
//}错误
class C{
//2.如果我们要求hi不能被子类重写，可以使用final修饰hi方法
public final void hi(){}
}
class D extends C{
// public void hi(){
// System.out.println("我重写了父类C类的hi方法....");
// }//错误
}
class E{
//3.当不希望类的某个属性的值被修改，可以用final修饰
public final double TAX_RATE = 0.08;
}
//4.当不希望某个局部变量被修改，可以使用final修饰
class F{
public void cry(){
//这时NUM也被称为局部变量
final double NUM = 0.01;
//NUM = 0.9;//错误
System.out.println("NUM=" + NUM);
}
}
FinalDetail01.java
package com.hspedu.final_;
public class FinalDetail01 {
public static void main(String[] args) {
CC cc = new CC();
new EE().cal();//cal()方法
}
}
class AA {
/*
2.final修饰的属性在定义时,必须赋初值,并且以后不能再修改，赋值可以在如下位置之一（选择一个位置赋值即可）:
a.定义时：如 public final double TAX_RATE=0.08;
b.在构造器中
c.在代码块中
*/
//1.final修饰的属性又叫常量,一般用XX_XX_XX来命名
public final double TAX_RATE = 0.08;//1.定义时赋值
public final double TAX_RATE2 ;
public final double TAX_RATE3 ;
public AA() {//构造器中赋值
TAX_RATE2 = 1.1;
}
{//在代码块赋值
TAX_RATE3 = 8.8;
}
}
class BB {
/*
3.如果final修饰的属性是静态的，则初始化的位置只能是
a.定义时
b.在静态代码块 不能在构造器中赋值。
*/
public static final double TAX_RATE = 99.9;
public static final double TAX_RATE2 ;
static {
TAX_RATE2 = 3.3;
}
}
//4.final类不能继承，但是可以实例化对象
final class CC { }
//5.如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可以被继承,即，仍然遵守继承的机制.
class DD {
public final void cal() {
System.out.println("cal()方法");
}
}
class EE extends DD { }
FinalDetail02.java
package com.hspedu.final_;
public class FinalDetail02 {
public static void main(String[] args) {
System.out.println(BBB.num);
/**
* 10000
* 不会输出代码块
*/
//包装类,String 是final类，不能被继承
//String;
//Double;
}
}
//final 和 static 往往搭配使用，效率更高，不会导致类加载.底层编译器做了优化处理
class BBB {
public final static int num = 10000;
static {
System.out.println("BBB 静态代码块被执行");
}
}
final class AAA{
//一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法
//public final void cry(){
}
FinalExercise01.java
package com.hspedu.final_;
public class FinalExercise01 {
public static void main(String[] args) {
Circle circle = new Circle(5.0);
System.out.println("面积=" + circle.calArea());
//面积=78.5
}
}
class Circle {
private double radius;
private final double PI = 3.14;
public Circle(double radius) {
this.radius = radius;
//PI = 3.14;
}
{
//PI = 3.14;
}
public double calArea(){
return PI * radius *radius;
}
}
FinalExercise02.java
package com.hspedu.final_;
public class FinalExercise02 {
public static void main(String[] args) {
}
}
class Something { //FinalExercise02.java
public int addOne(final int x) {
//下面的代码是否有误，为什么? 1min
//++x; //错误,原因是不能修改 final x的值
return x + 1; //这里是可以.
}
}