2018.3.6学习心得

最新推荐文章于 2018-03-08 21:07:23 发布

o_o_gl

最新推荐文章于 2018-03-08 21:07:23 发布

阅读量203

点赞数

本文链接：https://blog.csdn.net/o_o_gl/article/details/79457532

版权

package Student;

import java.util.Date;

//例如「南通青鸟 IT 教育 96 班同学在 3 教室上陆老师的 Java 课」。
//
//用面向对象的思维逻辑去分析，抽象实体：
//
//班级
//学生
//教室
//老师
//课程
//学校

// class
public class Student {
// 成员变量
String clazz;
String stu;
String clazzroom;
String teacher;
String lesson;
String school;

//构造器
public Student(String clazz, String stu, String clazzroom, String teacher, String lesson, String school) {
//超类（自动编译出来的）
super();

//申明属性
this.clazz = clazz;
this.stu = stu;
this.clazzroom = clazzroom;
this.teacher = teacher;
this.lesson = lesson;
this.school = school;
}
//主方法入口
public static void main(String[] args) {

//创建hh对象并赋值
Student hh = new Student("101班","学生","市北","老崔","Java","南通青鸟IT 教育");
//方法的调用
System.out.println(hh.intro());

}
//构造方法
String intro(){
return school + clazz + stu + "到" + clazzroom + "上" + teacher + "的" + lesson + "课";
}
}

=========================

针对今天上课已授知识点，进行了整理问题还有问题的答案。

1.Date报错。

Date在java.sql里会报错，鼠标移动到Date上点击切换成java.util就好了。

在顶部插入。

import java.util.Date;

2.java有哪些修饰符

public protected private final static abstract.pubilc protected private只能出现一个。

3.查一下super()；（超类）关键字的用法

super的用法
构造器和方法，都用关键字super指向超类，但是用的方法不一样。方法用这个关键字去执行被重载的超类中的方法。看下面的例子：

class Mammal {
void getBirthInfo() {
System.out.println("born alive.");
}
}

class Platypus extends Mammal {
void getBirthInfo() {
System.out.println("hatch from eggs");
System.out.print("a mammal normally is ");
super.getBirthInfo();
}
}

在上面的例子中，使用super.getBirthInfo()去调用超类Mammal中被重载的方法。

//1.super运用在构造函数中
class test1 extend test{
    public test1()...{
         super();//调用父类的构造函数
    }
    public test1(int x){
         super(x);//调用父类的构造函数,因为带形参所以super 也要带行参
    }
}
//2.调用父类中的成员
class test1 extend test{
    public test1(){}
    public f(){//假如父类里有一个成员叫g();
         super.g();//super引用当前对象的直接父类中的成员
    }
}

‍注意：1、 super()和this()调用语句不能同时在一个构造函数中出现
• super()或this()调用语句只能作为构造函数中的第一句出现。

构造器使用super去调用超类中的构造器。而且这行代码必须放在第一行，否则编译将出错。看下面的例子：

public class SuperClassDemo {
SuperClassDemo() {}
}

class Child extends SuperClassDemo {
Child() {
super();
}
}

在上面这个没有什么实际意义的例子中，构造器 Child()包含了 super,它的作用就是将超类中的构造器SuperClassDemo实例化，并加到 Child类中。

========================================================================================================

‍在Java中，this通常指当前对象，super则指父类的。当你想要引用当前对象的某种东西，比如当前对象的某个方法，或当前对象的某个成员，你便可以利用this来实现这个目的，当然，this的另一个用途是调用当前对象的另一个构造函数，这些马上就要讨论。如果你想引用父类的某种东西，则非super莫属。由于this与super有如此相似的一些特性和与生俱来的某种关系，所以我们在这一块儿来讨论，希望能帮助你区分和掌握它们两个。
在一般方法中
最普遍的情况就是，在你的方法中的某个形参名与当前对象的某个成员有相同的名字，这时为了不至于混淆，你便需要明确使用this关键字来指明你要使用某个成员，使用方法是“this.成员名”，而不带this的那个便是形参。另外，还可以用“this.方法名”来引用当前对象的某个方法，但这时this就不是必须的了，你可以直接用方法名来访问那个方法，编译器会知道你要调用的是那一个。下面的代码演示了上面的用法：
public class DemoThis{
private String name;
private int age;
DemoThis(String name,int age){
setName(name);
//你可以加上this来调用方法，像这样：this.setName(name);但这并不是必须的
setAge(age);
this.print(); br> }
public void setName(String name){
this.name=name;//此处必须指明你要引用成员变量
}
public void etAge(int age){
this.age=age;
}
public void print(){
System.out.println("Name="+name+" ge="+age);
//在此行中并不需要用this，因为没有会导致混淆的东西
}
public static void main(String[] args){
DemoThis dt=new DemoThis("Kevin","22");
这段代码很简单，不用解释你也应该能看明白。在构造函数中你看到用this.print(),你完全可以用print()来代替它，两者效果一样。下面我们修改这个程序，来演示super的用法。
class Person{
public int c;
private String name;
private int age;
protected void setName(String name){
this.name=name;
}
protected void setAge(int age){
this.age=age;
}
protected void print(){
System.out.println("Name="+name+" Age="+age);
}
}
public class DemoSuper extends Person{
public void print(){
System.out.println("DemoSuper:");
super.print();
}
public static void main(String[] args){
DemoSuper ds=new DemoSuper();
ds.setName("kevin");
ds.setAge(22);
ds.print();
}
}
在DemoSuper中，重新定义的print方法覆写了父类的print方法，它首先做一些自己的事情，然后调用父类的那个被覆写了的方法。输出结果说明了这一点：
DemoSuper:
Name=kevin Age=22

这样的使用方法是比较常用的。另外如果父类的成员可以被子类访问，那你可以像使用this一样使用它，用“super.父类中的成员名”的方式，但常常你并不是这样来访问父类中的成员名的。
在构造函数中构造函数是一种特殊的方法，在对象初始化的时候自动调用。在构造函数中，this和super也有上面说的种种使用方式，并且它还有特殊的地方，请看下面的例子：

class Person{

public static void prt(String s){
System.out.println(s);
}
Person(){
prt("A Person.");
}
Person(String name){
prt("A person name is:"+name);

}
}
public class Chinese extends Person{
Chinese(){
super(); //调用父类构造函数（1）
prt("A chinese.");//(4)
}
Chinese(String name){
super(name);//调用父类具有相同形参的构造函数（2）
prt("his name is:"+name);
}
Chinese(String name,int age){
this(name);//调用当前具有相同形参的构造函数（3）
prt("his age is:"+age);
}
public static void main(String[] args){
Chinese cn=new Chinese();
cn=new Chinese("kevin");
cn=new Chinese("kevin",22);
}
}
在这段程序中，this和super不再是像以前那样用“.”连接一个方法或成员，而是直接在其后跟
上适当的参数，因此它的意义也就有了变化。super后加参数的是用来调用父类中具有相同形式的
构造函数，如1和2处。this后加参数则调用的是当前具有相同参数的构造函数，如3处。当然，在
Chinese的各个重载构造函数中，this和super在一般方法中的各种用法也仍可使用，比如4处，你
可以将它替换为“this.prt”(因为它继承了父类中的那个方法）或者是“super.prt”（因为它
是父类中的方法且可被子类访问），它照样可以正确运行。但这样似乎就有点画蛇添足的味道
了。
最后，写了这么多，如果你能对“this通常指代当前对象，super通常指代父类”这句话牢记在
心，那么本篇便达到了目的，其它的你自会在以后的编程实践当中慢慢体会、掌握。另外关于本
篇中提到的继承，请参阅相关Java教程。

=====================================================================

4.date的数据类型。

把字符串转换成LocalDate ，必须使用下面这个格式 LocalDate date1 = LocalDate.parse("2014-05-26");

1.使用Date类和TimeStamp类的valueOf转换时间
Date.valueOf();
TimeStamp.valueOf();
如果这两种转换直接用在sal语句上，那么最外层要加双引号或单引号的；比如插入时间：insert into value('Date.valueOf("2012-12-12")');

2、在数据库中插入时间

PreparedStatement ps = con.prepareStatement("insert into TableName(dAddTime) values(?)");
这里有三种方式：
1) ps.setDate(1,new java.sql.Date(System.currentTimemillis()));
2) ps.setTime(2,new java.sql.Time(System.currentTimemillis()));
3) ps.setTimestamp(3,new java.sql.Timestamp(System.currentTimemillis()));
第一种只插入年月日 0000-00-00
第二种只插入时间 00:00:00
第三种则插入完整的时间 0000-00-00 00:00:00.000 .000是毫秒数。

3.java.sql.Date与java.util.Date类型转换

public static java.util.Date sqlDateToutilDate(java.sql.Date sdate)
{
java.util.Date udate = null;
long t = sdate.getTime();
udate = new Date(t);
return udate;
}
public static java.sql.Date utilDateTosqlDate(java.util.Date udate)
{
java.sql.Date sdate = null;
long t = udate.getTime();
sdate = new java.sql.Date(t);
return sdate;
}

public static void main(String[] args) {

Date date = new Date();
System.out.println("日期转字符串：" + ConvertDate.DateToStr(date));
System.out.println("字符串转日期：" + ConvertDate.StrToDate(ConvertDate.DateToStr(date)));

}

4.常见的java程序转换
//String转Date
public static void dataTest() {
SimpleDateFormat format = new SimpleDateFormat("2012-12-12 00:00:00");
Date lastModifyTime;
try {
lastModifyTime = format.parse("2012-12-12 00:00:00");
System.out.println(lastModifyTime.toLocaleString());
} catch (ParseException e) {
e.printStackTrace();
}
}

//Date转String
public static void testData() {
try {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
System.out.println(sdf.format("2012-12-12 01:12:11"));
System.out.println(java.sql.Timestamp.valueOf("2012-12-12 01:12:11"));
} catch (Exception e) {
e.printStackTrace();
}

}

===========================================================================

今天的知识点

类和对象

类：是一种自定义的数据类型。有时把这种数据类型也叫做「类类型」或者「引用数据类型」。「引用」就是内存地址的意思。

对象：通过类创建的变量，或者叫类的实体。

类是一群对象的特征母版，对象是类的具体实例。

类是一群对象的抽象。

类的定义

类所具备的最基本要素：（静态）属性、（动态）方法。

语法：

[修饰符] class 类名 {
    // 成员变量
    [修饰符] 数据类型 成员变量1;
    [修饰符] 数据类型 成员变量2;
    ...

    // 方法
    [修饰符] 返回值 方法名1([参数列表]) {
        方法体语句;
    }
    [修饰符] 返回值 方法名2([参数列表]) {
        方法体语句;
    }
    ...

    // 构造器：创建对象用的方法
    [修饰符] 类名([参数列表1]) {
        方法语句;
    }
    [修饰符] 类名([参数列表2]) {
        方法语句;
    }

}

类的三大部件：成员变量、方法、构造器。

实例：

public class Student1 {
    // 构造器
    Student1(String name, int age, String code) {
        this.name = name;
        this.age = age;
        this.code = code;
    }

    // 成员变量
    String name;
    int age;
    String code;

    // 方法
    String intro() {
        return "我叫"+this.name+"，我的学号是"+this.code+"，我今年"+this.age+"岁了。";
    }

    void listen() {
        System.out.println(this.name + "在上课。");
    }

}

使用类构建对象

public static void main(String[] args) {
    // 构建一个对象：调用类的构造器
    Student1 hehao = new Student1("何浩", 20, "C25");

    // 用对象：给属性赋值
    hehao.birthday = new Date(); // 赋值
    System.out.println(hehao.code); // 获取属性值

    // 用对象：调用对象的方法
    System.out.println(hehao.intro());
    hehao.listen();

}

类名的定义要符合 Java 的标识符命名规范，类名首字母大写，如果多个单词，使用驼峰命名法则（每个独立单词首字母大写），在 Java 中，只要看到首字母大写，你就是一个类。

类中三大部件的定义是没有严格的顺序的，但是，我们一般遵循，构造器、成员编程、方法这样的定义顺序。

构造器

语法：

[修饰符] 类名([参数列表]) {}

构造器是一个特殊的方法，方法名就是类名，没有返回值（和 void 是有区别的），构造器是类创建对象的唯一途径。如果一个类没有显式的定义一个构造器，那么编译器会给这个类默认的定义一个没有参数的构造器。
如果显式的定义了一个构造器，那么编译器就不会给类定义默认的空参数构造器。

成员变量

语法：

[修饰符] 数据类型 成员变量名 [= 默认值];

修饰符：可以省略，也可以是 public protected private static final，其中 public protected private 只允许出现一个。
数据类型：可以是任意的数据类型（包含基本数据类型、类类型、数组类型）
默认值：如果是类类型的，没有定义默认值，那么成员变量的值为 null，如果是基本数据，没有定义默认值，那么成员变量的值是有意义的，比如 int 就是 0，boolean 就是 false。

方法

语法：

[修饰符] 方法的返回值数据类型 方法名(形参列表) {
    方法体语句;
}

修饰符：可以省略，也可以是 public protected private static final abstract，其中 public protected private 只允许出现一个
返回值：可以是数据类型（不要忘了自定义的数据类型），也可以是 void，如果定义了返回值，那么就必须在 return 后面跟随该类型的值或者对象。
方法名：一般首字母小写，也适用驼峰命名法则，一般是动词在前，名词在后，不易过长
形参列表：定义方法可以接受的参数，由 0-N 个「数据类型参数名」通过「,」组合的。一旦方法指定了形参，那么在调用的时候就必须一一对应的传入实参。

static 关键字

用于修饰成员变量和方法，用 static 修饰的成员变量后者方法是属于类的，而不属于该类的实例（对象）。通常把 static 修饰的成员变量称为「类变量、静态变量」，方法称为「类方法、静态方法」

静态的成员是不能访问非静态成员的；

静态成员之间是可以互相访问的。

static String teacher = "陆老师";

// 方法

static String fun2() {
    System.out.println(this.name); // 错误代码
    System.out.println(teacher);
    return "";
}

使用一个对象的过程

定义类
构建和使用对象

语法：

类类型 对象名 = new 构造器方法();

实例：

Student1 hehao = new Student1("何浩", 20, "C25");

在内存中的执行过程：

1、在栈内存中，会存储对象名，在没有执行构造器创建对象并赋值时，此时对象名对应的值为 null；

2、通过 new 关键字调用类的构造器在堆内存中分配了一块对象区域；

3、通过赋值运算符 = ，将堆内存中的对象地址赋给栈内存中的变量名；

4、例如再次给对象的属性赋值：通过栈内存定位到对象在堆内存中的地址，找到相应的成员变量，进行赋值操作。

引用，还可以称为「地址」、「指针」，特指类类型，因为只有类类型才会在堆内存中分配对象空间，并将地址（指针）在栈内存中用于对象变量名的引用。

this 关键字

Java 中使用 this 关键字，指向调用该方法的对象。根据 this 所在的位置，大致分为两种：

出现在构造器中：引用该构造器正在初始化的对象；
普通方法中：调用该方法的对象。

this 用于在类定义中，获取当前对象的属性，或者调用当前对象的方法。

在类定义中，可以省略 this 关键字去调用属性或者方法，但是在类被编译的时候，编译器还是会加上 this 关键字。所以强烈建议在类定义时如果要调用该类中的普通成员变量或者方法，还是要把 this 加上去。

用 static 修饰的方法中是不能使用 this 关键字的。

Student1(String name, int age, String code) {
    this.name = name;
    this.age = age;
    this.code = code;
}

String intro() {
    return "我叫" + this.name + "，我的学号是" + this.code + "，我今年" + this.age + "岁了。";
}

void listen() {
    System.out.println("自我介绍：" + this.intro() + "  " + this.name + "在上课。");
    return;
}

static String fun2() {
    return this.intro(); // 错误代码
}

o_o_gl

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
2018.3.6学习心得

package Student;import java.util.Date;//例如「南通青鸟 IT 教育 96 班同学在 3 教室上陆老师的 Java 课」。////用面向对象的思维逻辑去分析，抽象实体：////班级//学生//教室//老师//课程//学校// classpublic class Student {// 成员变量 String clazz; String stu; String...
复制链接

扫一扫